diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 511722b9..d9a5d555 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +1,3 @@
 {
-  ".": "1.20.1"
+  ".": "1.20.2"
 }
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b9a12e53..16e10ba8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.20.2 (2026-02-27)
+
+Full Changelog: [v1.20.1...v1.20.2](https://github.com/knocklabs/knock-python/compare/v1.20.1...v1.20.2)
+
+### Chores
+
+* **docs:** add missing descriptions ([02bea2b](https://github.com/knocklabs/knock-python/commit/02bea2b275c9680072ed89fb06634e957f017292))
+
 ## 1.20.1 (2026-02-24)
 
 Full Changelog: [v1.20.0...v1.20.1](https://github.com/knocklabs/knock-python/compare/v1.20.0...v1.20.1)
diff --git a/pyproject.toml b/pyproject.toml
index 22966067..9de699bb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "knockapi"
-version = "1.20.1"
+version = "1.20.2"
 description = "The official Python library for the knock API"
 dynamic = ["readme"]
 license = "Apache-2.0"
diff --git a/src/knockapi/_client.py b/src/knockapi/_client.py
index c7bbfdca..772dbcad 100644
--- a/src/knockapi/_client.py
+++ b/src/knockapi/_client.py
@@ -126,30 +126,42 @@ def __init__(
 
     @cached_property
     def users(self) -> UsersResource:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         from .resources.users import UsersResource
 
         return UsersResource(self)
 
     @cached_property
     def objects(self) -> ObjectsResource:
+        """An object represents a resource in your system that you want to map into Knock."""
         from .resources.objects import ObjectsResource
 
         return ObjectsResource(self)
 
     @cached_property
     def tenants(self) -> TenantsResource:
+        """
+        A tenant represents a top-level entity from your system, like a company, organization, account, or workspace.
+        """
         from .resources.tenants import TenantsResource
 
         return TenantsResource(self)
 
     @cached_property
     def bulk_operations(self) -> BulkOperationsResource:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         from .resources.bulk_operations import BulkOperationsResource
 
         return BulkOperationsResource(self)
 
     @cached_property
     def messages(self) -> MessagesResource:
+        """A message sent to a single recipient on a channel."""
         from .resources.messages import MessagesResource
 
         return MessagesResource(self)
@@ -168,12 +180,18 @@ def integrations(self) -> IntegrationsResource:
 
     @cached_property
     def workflows(self) -> WorkflowsResource:
+        """
+        A workflow is a structured set of steps that is triggered to produce notifications sent over channels.
+        """
         from .resources.workflows import WorkflowsResource
 
         return WorkflowsResource(self)
 
     @cached_property
     def schedules(self) -> SchedulesResource:
+        """
+        A schedule is a per-recipient, timezone-aware configuration for when to invoke a workflow.
+        """
         from .resources.schedules import SchedulesResource
 
         return SchedulesResource(self)
@@ -186,6 +204,7 @@ def channels(self) -> ChannelsResource:
 
     @cached_property
     def audiences(self) -> AudiencesResource:
+        """An Audience is a segment of users."""
         from .resources.audiences import AudiencesResource
 
         return AudiencesResource(self)
@@ -373,30 +392,42 @@ def __init__(
 
     @cached_property
     def users(self) -> AsyncUsersResource:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         from .resources.users import AsyncUsersResource
 
         return AsyncUsersResource(self)
 
     @cached_property
     def objects(self) -> AsyncObjectsResource:
+        """An object represents a resource in your system that you want to map into Knock."""
         from .resources.objects import AsyncObjectsResource
 
         return AsyncObjectsResource(self)
 
     @cached_property
     def tenants(self) -> AsyncTenantsResource:
+        """
+        A tenant represents a top-level entity from your system, like a company, organization, account, or workspace.
+        """
         from .resources.tenants import AsyncTenantsResource
 
         return AsyncTenantsResource(self)
 
     @cached_property
     def bulk_operations(self) -> AsyncBulkOperationsResource:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         from .resources.bulk_operations import AsyncBulkOperationsResource
 
         return AsyncBulkOperationsResource(self)
 
     @cached_property
     def messages(self) -> AsyncMessagesResource:
+        """A message sent to a single recipient on a channel."""
         from .resources.messages import AsyncMessagesResource
 
         return AsyncMessagesResource(self)
@@ -415,12 +446,18 @@ def integrations(self) -> AsyncIntegrationsResource:
 
     @cached_property
     def workflows(self) -> AsyncWorkflowsResource:
+        """
+        A workflow is a structured set of steps that is triggered to produce notifications sent over channels.
+        """
         from .resources.workflows import AsyncWorkflowsResource
 
         return AsyncWorkflowsResource(self)
 
     @cached_property
     def schedules(self) -> AsyncSchedulesResource:
+        """
+        A schedule is a per-recipient, timezone-aware configuration for when to invoke a workflow.
+        """
         from .resources.schedules import AsyncSchedulesResource
 
         return AsyncSchedulesResource(self)
@@ -433,6 +470,7 @@ def channels(self) -> AsyncChannelsResource:
 
     @cached_property
     def audiences(self) -> AsyncAudiencesResource:
+        """An Audience is a segment of users."""
         from .resources.audiences import AsyncAudiencesResource
 
         return AsyncAudiencesResource(self)
@@ -561,30 +599,42 @@ def __init__(self, client: Knock) -> None:
 
     @cached_property
     def users(self) -> users.UsersResourceWithRawResponse:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         from .resources.users import UsersResourceWithRawResponse
 
         return UsersResourceWithRawResponse(self._client.users)
 
     @cached_property
     def objects(self) -> objects.ObjectsResourceWithRawResponse:
+        """An object represents a resource in your system that you want to map into Knock."""
         from .resources.objects import ObjectsResourceWithRawResponse
 
         return ObjectsResourceWithRawResponse(self._client.objects)
 
     @cached_property
     def tenants(self) -> tenants.TenantsResourceWithRawResponse:
+        """
+        A tenant represents a top-level entity from your system, like a company, organization, account, or workspace.
+        """
         from .resources.tenants import TenantsResourceWithRawResponse
 
         return TenantsResourceWithRawResponse(self._client.tenants)
 
     @cached_property
     def bulk_operations(self) -> bulk_operations.BulkOperationsResourceWithRawResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         from .resources.bulk_operations import BulkOperationsResourceWithRawResponse
 
         return BulkOperationsResourceWithRawResponse(self._client.bulk_operations)
 
     @cached_property
     def messages(self) -> messages.MessagesResourceWithRawResponse:
+        """A message sent to a single recipient on a channel."""
         from .resources.messages import MessagesResourceWithRawResponse
 
         return MessagesResourceWithRawResponse(self._client.messages)
@@ -603,12 +653,18 @@ def integrations(self) -> integrations.IntegrationsResourceWithRawResponse:
 
     @cached_property
     def workflows(self) -> workflows.WorkflowsResourceWithRawResponse:
+        """
+        A workflow is a structured set of steps that is triggered to produce notifications sent over channels.
+        """
         from .resources.workflows import WorkflowsResourceWithRawResponse
 
         return WorkflowsResourceWithRawResponse(self._client.workflows)
 
     @cached_property
     def schedules(self) -> schedules.SchedulesResourceWithRawResponse:
+        """
+        A schedule is a per-recipient, timezone-aware configuration for when to invoke a workflow.
+        """
         from .resources.schedules import SchedulesResourceWithRawResponse
 
         return SchedulesResourceWithRawResponse(self._client.schedules)
@@ -621,6 +677,7 @@ def channels(self) -> channels.ChannelsResourceWithRawResponse:
 
     @cached_property
     def audiences(self) -> audiences.AudiencesResourceWithRawResponse:
+        """An Audience is a segment of users."""
         from .resources.audiences import AudiencesResourceWithRawResponse
 
         return AudiencesResourceWithRawResponse(self._client.audiences)
@@ -634,30 +691,42 @@ def __init__(self, client: AsyncKnock) -> None:
 
     @cached_property
     def users(self) -> users.AsyncUsersResourceWithRawResponse:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         from .resources.users import AsyncUsersResourceWithRawResponse
 
         return AsyncUsersResourceWithRawResponse(self._client.users)
 
     @cached_property
     def objects(self) -> objects.AsyncObjectsResourceWithRawResponse:
+        """An object represents a resource in your system that you want to map into Knock."""
         from .resources.objects import AsyncObjectsResourceWithRawResponse
 
         return AsyncObjectsResourceWithRawResponse(self._client.objects)
 
     @cached_property
     def tenants(self) -> tenants.AsyncTenantsResourceWithRawResponse:
+        """
+        A tenant represents a top-level entity from your system, like a company, organization, account, or workspace.
+        """
         from .resources.tenants import AsyncTenantsResourceWithRawResponse
 
         return AsyncTenantsResourceWithRawResponse(self._client.tenants)
 
     @cached_property
     def bulk_operations(self) -> bulk_operations.AsyncBulkOperationsResourceWithRawResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         from .resources.bulk_operations import AsyncBulkOperationsResourceWithRawResponse
 
         return AsyncBulkOperationsResourceWithRawResponse(self._client.bulk_operations)
 
     @cached_property
     def messages(self) -> messages.AsyncMessagesResourceWithRawResponse:
+        """A message sent to a single recipient on a channel."""
         from .resources.messages import AsyncMessagesResourceWithRawResponse
 
         return AsyncMessagesResourceWithRawResponse(self._client.messages)
@@ -676,12 +745,18 @@ def integrations(self) -> integrations.AsyncIntegrationsResourceWithRawResponse:
 
     @cached_property
     def workflows(self) -> workflows.AsyncWorkflowsResourceWithRawResponse:
+        """
+        A workflow is a structured set of steps that is triggered to produce notifications sent over channels.
+        """
         from .resources.workflows import AsyncWorkflowsResourceWithRawResponse
 
         return AsyncWorkflowsResourceWithRawResponse(self._client.workflows)
 
     @cached_property
     def schedules(self) -> schedules.AsyncSchedulesResourceWithRawResponse:
+        """
+        A schedule is a per-recipient, timezone-aware configuration for when to invoke a workflow.
+        """
         from .resources.schedules import AsyncSchedulesResourceWithRawResponse
 
         return AsyncSchedulesResourceWithRawResponse(self._client.schedules)
@@ -694,6 +769,7 @@ def channels(self) -> channels.AsyncChannelsResourceWithRawResponse:
 
     @cached_property
     def audiences(self) -> audiences.AsyncAudiencesResourceWithRawResponse:
+        """An Audience is a segment of users."""
         from .resources.audiences import AsyncAudiencesResourceWithRawResponse
 
         return AsyncAudiencesResourceWithRawResponse(self._client.audiences)
@@ -707,30 +783,42 @@ def __init__(self, client: Knock) -> None:
 
     @cached_property
     def users(self) -> users.UsersResourceWithStreamingResponse:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         from .resources.users import UsersResourceWithStreamingResponse
 
         return UsersResourceWithStreamingResponse(self._client.users)
 
     @cached_property
     def objects(self) -> objects.ObjectsResourceWithStreamingResponse:
+        """An object represents a resource in your system that you want to map into Knock."""
         from .resources.objects import ObjectsResourceWithStreamingResponse
 
         return ObjectsResourceWithStreamingResponse(self._client.objects)
 
     @cached_property
     def tenants(self) -> tenants.TenantsResourceWithStreamingResponse:
+        """
+        A tenant represents a top-level entity from your system, like a company, organization, account, or workspace.
+        """
         from .resources.tenants import TenantsResourceWithStreamingResponse
 
         return TenantsResourceWithStreamingResponse(self._client.tenants)
 
     @cached_property
     def bulk_operations(self) -> bulk_operations.BulkOperationsResourceWithStreamingResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         from .resources.bulk_operations import BulkOperationsResourceWithStreamingResponse
 
         return BulkOperationsResourceWithStreamingResponse(self._client.bulk_operations)
 
     @cached_property
     def messages(self) -> messages.MessagesResourceWithStreamingResponse:
+        """A message sent to a single recipient on a channel."""
         from .resources.messages import MessagesResourceWithStreamingResponse
 
         return MessagesResourceWithStreamingResponse(self._client.messages)
@@ -749,12 +837,18 @@ def integrations(self) -> integrations.IntegrationsResourceWithStreamingResponse
 
     @cached_property
     def workflows(self) -> workflows.WorkflowsResourceWithStreamingResponse:
+        """
+        A workflow is a structured set of steps that is triggered to produce notifications sent over channels.
+        """
         from .resources.workflows import WorkflowsResourceWithStreamingResponse
 
         return WorkflowsResourceWithStreamingResponse(self._client.workflows)
 
     @cached_property
     def schedules(self) -> schedules.SchedulesResourceWithStreamingResponse:
+        """
+        A schedule is a per-recipient, timezone-aware configuration for when to invoke a workflow.
+        """
         from .resources.schedules import SchedulesResourceWithStreamingResponse
 
         return SchedulesResourceWithStreamingResponse(self._client.schedules)
@@ -767,6 +861,7 @@ def channels(self) -> channels.ChannelsResourceWithStreamingResponse:
 
     @cached_property
     def audiences(self) -> audiences.AudiencesResourceWithStreamingResponse:
+        """An Audience is a segment of users."""
         from .resources.audiences import AudiencesResourceWithStreamingResponse
 
         return AudiencesResourceWithStreamingResponse(self._client.audiences)
@@ -780,30 +875,42 @@ def __init__(self, client: AsyncKnock) -> None:
 
     @cached_property
     def users(self) -> users.AsyncUsersResourceWithStreamingResponse:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         from .resources.users import AsyncUsersResourceWithStreamingResponse
 
         return AsyncUsersResourceWithStreamingResponse(self._client.users)
 
     @cached_property
     def objects(self) -> objects.AsyncObjectsResourceWithStreamingResponse:
+        """An object represents a resource in your system that you want to map into Knock."""
         from .resources.objects import AsyncObjectsResourceWithStreamingResponse
 
         return AsyncObjectsResourceWithStreamingResponse(self._client.objects)
 
     @cached_property
     def tenants(self) -> tenants.AsyncTenantsResourceWithStreamingResponse:
+        """
+        A tenant represents a top-level entity from your system, like a company, organization, account, or workspace.
+        """
         from .resources.tenants import AsyncTenantsResourceWithStreamingResponse
 
         return AsyncTenantsResourceWithStreamingResponse(self._client.tenants)
 
     @cached_property
     def bulk_operations(self) -> bulk_operations.AsyncBulkOperationsResourceWithStreamingResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         from .resources.bulk_operations import AsyncBulkOperationsResourceWithStreamingResponse
 
         return AsyncBulkOperationsResourceWithStreamingResponse(self._client.bulk_operations)
 
     @cached_property
     def messages(self) -> messages.AsyncMessagesResourceWithStreamingResponse:
+        """A message sent to a single recipient on a channel."""
         from .resources.messages import AsyncMessagesResourceWithStreamingResponse
 
         return AsyncMessagesResourceWithStreamingResponse(self._client.messages)
@@ -822,12 +929,18 @@ def integrations(self) -> integrations.AsyncIntegrationsResourceWithStreamingRes
 
     @cached_property
     def workflows(self) -> workflows.AsyncWorkflowsResourceWithStreamingResponse:
+        """
+        A workflow is a structured set of steps that is triggered to produce notifications sent over channels.
+        """
         from .resources.workflows import AsyncWorkflowsResourceWithStreamingResponse
 
         return AsyncWorkflowsResourceWithStreamingResponse(self._client.workflows)
 
     @cached_property
     def schedules(self) -> schedules.AsyncSchedulesResourceWithStreamingResponse:
+        """
+        A schedule is a per-recipient, timezone-aware configuration for when to invoke a workflow.
+        """
         from .resources.schedules import AsyncSchedulesResourceWithStreamingResponse
 
         return AsyncSchedulesResourceWithStreamingResponse(self._client.schedules)
@@ -840,6 +953,7 @@ def channels(self) -> channels.AsyncChannelsResourceWithStreamingResponse:
 
     @cached_property
     def audiences(self) -> audiences.AsyncAudiencesResourceWithStreamingResponse:
+        """An Audience is a segment of users."""
         from .resources.audiences import AsyncAudiencesResourceWithStreamingResponse
 
         return AsyncAudiencesResourceWithStreamingResponse(self._client.audiences)
diff --git a/src/knockapi/_version.py b/src/knockapi/_version.py
index 1b3728b7..e330fcb9 100644
--- a/src/knockapi/_version.py
+++ b/src/knockapi/_version.py
@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "knockapi"
-__version__ = "1.20.1"  # x-release-please-version
+__version__ = "1.20.2"  # x-release-please-version
diff --git a/src/knockapi/resources/audiences.py b/src/knockapi/resources/audiences.py
index a40199db..2ab417d9 100644
--- a/src/knockapi/resources/audiences.py
+++ b/src/knockapi/resources/audiences.py
@@ -24,6 +24,8 @@
 
 
 class AudiencesResource(SyncAPIResource):
+    """An Audience is a segment of users."""
+
     @cached_property
     def with_raw_response(self) -> AudiencesResourceWithRawResponse:
         """
@@ -175,6 +177,8 @@ def remove_members(
 
 
 class AsyncAudiencesResource(AsyncAPIResource):
+    """An Audience is a segment of users."""
+
     @cached_property
     def with_raw_response(self) -> AsyncAudiencesResourceWithRawResponse:
         """
diff --git a/src/knockapi/resources/bulk_operations.py b/src/knockapi/resources/bulk_operations.py
index c006ef52..1cf6d595 100644
--- a/src/knockapi/resources/bulk_operations.py
+++ b/src/knockapi/resources/bulk_operations.py
@@ -20,6 +20,10 @@
 
 
 class BulkOperationsResource(SyncAPIResource):
+    """
+    A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+    """
+
     @cached_property
     def with_raw_response(self) -> BulkOperationsResourceWithRawResponse:
         """
@@ -74,6 +78,10 @@ def get(
 
 
 class AsyncBulkOperationsResource(AsyncAPIResource):
+    """
+    A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncBulkOperationsResourceWithRawResponse:
         """
diff --git a/src/knockapi/resources/channels/bulk.py b/src/knockapi/resources/channels/bulk.py
index a5e06bae..db127642 100644
--- a/src/knockapi/resources/channels/bulk.py
+++ b/src/knockapi/resources/channels/bulk.py
@@ -26,6 +26,10 @@
 
 
 class BulkResource(SyncAPIResource):
+    """
+    A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+    """
+
     @cached_property
     def with_raw_response(self) -> BulkResourceWithRawResponse:
         """
@@ -149,6 +153,10 @@ def update_message_status(
 
 
 class AsyncBulkResource(AsyncAPIResource):
+    """
+    A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncBulkResourceWithRawResponse:
         """
diff --git a/src/knockapi/resources/channels/channels.py b/src/knockapi/resources/channels/channels.py
index c15c248b..7b016b54 100644
--- a/src/knockapi/resources/channels/channels.py
+++ b/src/knockapi/resources/channels/channels.py
@@ -19,6 +19,9 @@
 class ChannelsResource(SyncAPIResource):
     @cached_property
     def bulk(self) -> BulkResource:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResource(self._client)
 
     @cached_property
@@ -44,6 +47,9 @@ def with_streaming_response(self) -> ChannelsResourceWithStreamingResponse:
 class AsyncChannelsResource(AsyncAPIResource):
     @cached_property
     def bulk(self) -> AsyncBulkResource:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResource(self._client)
 
     @cached_property
@@ -72,6 +78,9 @@ def __init__(self, channels: ChannelsResource) -> None:
 
     @cached_property
     def bulk(self) -> BulkResourceWithRawResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResourceWithRawResponse(self._channels.bulk)
 
 
@@ -81,6 +90,9 @@ def __init__(self, channels: AsyncChannelsResource) -> None:
 
     @cached_property
     def bulk(self) -> AsyncBulkResourceWithRawResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResourceWithRawResponse(self._channels.bulk)
 
 
@@ -90,6 +102,9 @@ def __init__(self, channels: ChannelsResource) -> None:
 
     @cached_property
     def bulk(self) -> BulkResourceWithStreamingResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResourceWithStreamingResponse(self._channels.bulk)
 
 
@@ -99,4 +114,7 @@ def __init__(self, channels: AsyncChannelsResource) -> None:
 
     @cached_property
     def bulk(self) -> AsyncBulkResourceWithStreamingResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResourceWithStreamingResponse(self._channels.bulk)
diff --git a/src/knockapi/resources/messages/batch.py b/src/knockapi/resources/messages/batch.py
index a38f5b0a..1b3fb2f1 100644
--- a/src/knockapi/resources/messages/batch.py
+++ b/src/knockapi/resources/messages/batch.py
@@ -40,6 +40,8 @@
 
 
 class BatchResource(SyncAPIResource):
+    """A message sent to a single recipient on a channel."""
+
     @cached_property
     def with_raw_response(self) -> BatchResourceWithRawResponse:
         """
@@ -415,6 +417,8 @@ def unarchive(
 
 
 class AsyncBatchResource(AsyncAPIResource):
+    """A message sent to a single recipient on a channel."""
+
     @cached_property
     def with_raw_response(self) -> AsyncBatchResourceWithRawResponse:
         """
diff --git a/src/knockapi/resources/messages/messages.py b/src/knockapi/resources/messages/messages.py
index 25bdafd6..1e6c70c8 100644
--- a/src/knockapi/resources/messages/messages.py
+++ b/src/knockapi/resources/messages/messages.py
@@ -44,8 +44,11 @@
 
 
 class MessagesResource(SyncAPIResource):
+    """A message sent to a single recipient on a channel."""
+
     @cached_property
     def batch(self) -> BatchResource:
+        """A message sent to a single recipient on a channel."""
         return BatchResource(self._client)
 
     @cached_property
@@ -709,8 +712,11 @@ def unarchive(
 
 
 class AsyncMessagesResource(AsyncAPIResource):
+    """A message sent to a single recipient on a channel."""
+
     @cached_property
     def batch(self) -> AsyncBatchResource:
+        """A message sent to a single recipient on a channel."""
         return AsyncBatchResource(self._client)
 
     @cached_property
@@ -1419,6 +1425,7 @@ def __init__(self, messages: MessagesResource) -> None:
 
     @cached_property
     def batch(self) -> BatchResourceWithRawResponse:
+        """A message sent to a single recipient on a channel."""
         return BatchResourceWithRawResponse(self._messages.batch)
 
 
@@ -1468,6 +1475,7 @@ def __init__(self, messages: AsyncMessagesResource) -> None:
 
     @cached_property
     def batch(self) -> AsyncBatchResourceWithRawResponse:
+        """A message sent to a single recipient on a channel."""
         return AsyncBatchResourceWithRawResponse(self._messages.batch)
 
 
@@ -1517,6 +1525,7 @@ def __init__(self, messages: MessagesResource) -> None:
 
     @cached_property
     def batch(self) -> BatchResourceWithStreamingResponse:
+        """A message sent to a single recipient on a channel."""
         return BatchResourceWithStreamingResponse(self._messages.batch)
 
 
@@ -1566,4 +1575,5 @@ def __init__(self, messages: AsyncMessagesResource) -> None:
 
     @cached_property
     def batch(self) -> AsyncBatchResourceWithStreamingResponse:
+        """A message sent to a single recipient on a channel."""
         return AsyncBatchResourceWithStreamingResponse(self._messages.batch)
diff --git a/src/knockapi/resources/objects/bulk.py b/src/knockapi/resources/objects/bulk.py
index a84b55fb..de559248 100644
--- a/src/knockapi/resources/objects/bulk.py
+++ b/src/knockapi/resources/objects/bulk.py
@@ -29,6 +29,10 @@
 
 
 class BulkResource(SyncAPIResource):
+    """
+    A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+    """
+
     @cached_property
     def with_raw_response(self) -> BulkResourceWithRawResponse:
         """
@@ -237,6 +241,10 @@ def set(
 
 
 class AsyncBulkResource(AsyncAPIResource):
+    """
+    A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncBulkResourceWithRawResponse:
         """
diff --git a/src/knockapi/resources/objects/objects.py b/src/knockapi/resources/objects/objects.py
index 598326a1..96c7bc1e 100644
--- a/src/knockapi/resources/objects/objects.py
+++ b/src/knockapi/resources/objects/objects.py
@@ -57,8 +57,13 @@
 
 
 class ObjectsResource(SyncAPIResource):
+    """An object represents a resource in your system that you want to map into Knock."""
+
     @cached_property
     def bulk(self) -> BulkResource:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResource(self._client)
 
     @cached_property
@@ -968,8 +973,13 @@ def unset_channel_data(
 
 
 class AsyncObjectsResource(AsyncAPIResource):
+    """An object represents a resource in your system that you want to map into Knock."""
+
     @cached_property
     def bulk(self) -> AsyncBulkResource:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResource(self._client)
 
     @cached_property
@@ -1930,6 +1940,9 @@ def __init__(self, objects: ObjectsResource) -> None:
 
     @cached_property
     def bulk(self) -> BulkResourceWithRawResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResourceWithRawResponse(self._objects.bulk)
 
 
@@ -1985,6 +1998,9 @@ def __init__(self, objects: AsyncObjectsResource) -> None:
 
     @cached_property
     def bulk(self) -> AsyncBulkResourceWithRawResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResourceWithRawResponse(self._objects.bulk)
 
 
@@ -2040,6 +2056,9 @@ def __init__(self, objects: ObjectsResource) -> None:
 
     @cached_property
     def bulk(self) -> BulkResourceWithStreamingResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResourceWithStreamingResponse(self._objects.bulk)
 
 
@@ -2095,4 +2114,7 @@ def __init__(self, objects: AsyncObjectsResource) -> None:
 
     @cached_property
     def bulk(self) -> AsyncBulkResourceWithStreamingResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResourceWithStreamingResponse(self._objects.bulk)
diff --git a/src/knockapi/resources/providers/ms_teams.py b/src/knockapi/resources/providers/ms_teams.py
index 9035ddc0..c5fd020b 100644
--- a/src/knockapi/resources/providers/ms_teams.py
+++ b/src/knockapi/resources/providers/ms_teams.py
@@ -31,6 +31,10 @@
 
 
 class MsTeamsResource(SyncAPIResource):
+    """
+    A provider represents a third-party service that Knock integrates with and is configured via a channel.
+    """
+
     @cached_property
     def with_raw_response(self) -> MsTeamsResourceWithRawResponse:
         """
@@ -245,6 +249,10 @@ def revoke_access(
 
 
 class AsyncMsTeamsResource(AsyncAPIResource):
+    """
+    A provider represents a third-party service that Knock integrates with and is configured via a channel.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncMsTeamsResourceWithRawResponse:
         """
diff --git a/src/knockapi/resources/providers/providers.py b/src/knockapi/resources/providers/providers.py
index 1dd36a5b..87e95d7b 100644
--- a/src/knockapi/resources/providers/providers.py
+++ b/src/knockapi/resources/providers/providers.py
@@ -27,10 +27,16 @@
 class ProvidersResource(SyncAPIResource):
     @cached_property
     def slack(self) -> SlackResource:
+        """
+        A provider represents a third-party service that Knock integrates with and is configured via a channel.
+        """
         return SlackResource(self._client)
 
     @cached_property
     def ms_teams(self) -> MsTeamsResource:
+        """
+        A provider represents a third-party service that Knock integrates with and is configured via a channel.
+        """
         return MsTeamsResource(self._client)
 
     @cached_property
@@ -56,10 +62,16 @@ def with_streaming_response(self) -> ProvidersResourceWithStreamingResponse:
 class AsyncProvidersResource(AsyncAPIResource):
     @cached_property
     def slack(self) -> AsyncSlackResource:
+        """
+        A provider represents a third-party service that Knock integrates with and is configured via a channel.
+        """
         return AsyncSlackResource(self._client)
 
     @cached_property
     def ms_teams(self) -> AsyncMsTeamsResource:
+        """
+        A provider represents a third-party service that Knock integrates with and is configured via a channel.
+        """
         return AsyncMsTeamsResource(self._client)
 
     @cached_property
@@ -88,10 +100,16 @@ def __init__(self, providers: ProvidersResource) -> None:
 
     @cached_property
     def slack(self) -> SlackResourceWithRawResponse:
+        """
+        A provider represents a third-party service that Knock integrates with and is configured via a channel.
+        """
         return SlackResourceWithRawResponse(self._providers.slack)
 
     @cached_property
     def ms_teams(self) -> MsTeamsResourceWithRawResponse:
+        """
+        A provider represents a third-party service that Knock integrates with and is configured via a channel.
+        """
         return MsTeamsResourceWithRawResponse(self._providers.ms_teams)
 
 
@@ -101,10 +119,16 @@ def __init__(self, providers: AsyncProvidersResource) -> None:
 
     @cached_property
     def slack(self) -> AsyncSlackResourceWithRawResponse:
+        """
+        A provider represents a third-party service that Knock integrates with and is configured via a channel.
+        """
         return AsyncSlackResourceWithRawResponse(self._providers.slack)
 
     @cached_property
     def ms_teams(self) -> AsyncMsTeamsResourceWithRawResponse:
+        """
+        A provider represents a third-party service that Knock integrates with and is configured via a channel.
+        """
         return AsyncMsTeamsResourceWithRawResponse(self._providers.ms_teams)
 
 
@@ -114,10 +138,16 @@ def __init__(self, providers: ProvidersResource) -> None:
 
     @cached_property
     def slack(self) -> SlackResourceWithStreamingResponse:
+        """
+        A provider represents a third-party service that Knock integrates with and is configured via a channel.
+        """
         return SlackResourceWithStreamingResponse(self._providers.slack)
 
     @cached_property
     def ms_teams(self) -> MsTeamsResourceWithStreamingResponse:
+        """
+        A provider represents a third-party service that Knock integrates with and is configured via a channel.
+        """
         return MsTeamsResourceWithStreamingResponse(self._providers.ms_teams)
 
 
@@ -127,8 +157,14 @@ def __init__(self, providers: AsyncProvidersResource) -> None:
 
     @cached_property
     def slack(self) -> AsyncSlackResourceWithStreamingResponse:
+        """
+        A provider represents a third-party service that Knock integrates with and is configured via a channel.
+        """
         return AsyncSlackResourceWithStreamingResponse(self._providers.slack)
 
     @cached_property
     def ms_teams(self) -> AsyncMsTeamsResourceWithStreamingResponse:
+        """
+        A provider represents a third-party service that Knock integrates with and is configured via a channel.
+        """
         return AsyncMsTeamsResourceWithStreamingResponse(self._providers.ms_teams)
diff --git a/src/knockapi/resources/providers/slack.py b/src/knockapi/resources/providers/slack.py
index d7172ee6..d9939596 100644
--- a/src/knockapi/resources/providers/slack.py
+++ b/src/knockapi/resources/providers/slack.py
@@ -25,6 +25,10 @@
 
 
 class SlackResource(SyncAPIResource):
+    """
+    A provider represents a third-party service that Knock integrates with and is configured via a channel.
+    """
+
     @cached_property
     def with_raw_response(self) -> SlackResourceWithRawResponse:
         """
@@ -182,6 +186,10 @@ def revoke_access(
 
 
 class AsyncSlackResource(AsyncAPIResource):
+    """
+    A provider represents a third-party service that Knock integrates with and is configured via a channel.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncSlackResourceWithRawResponse:
         """
diff --git a/src/knockapi/resources/schedules/bulk.py b/src/knockapi/resources/schedules/bulk.py
index 6e1fdbd9..f5aed220 100644
--- a/src/knockapi/resources/schedules/bulk.py
+++ b/src/knockapi/resources/schedules/bulk.py
@@ -24,6 +24,10 @@
 
 
 class BulkResource(SyncAPIResource):
+    """
+    A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+    """
+
     @cached_property
     def with_raw_response(self) -> BulkResourceWithRawResponse:
         """
@@ -89,6 +93,10 @@ def create(
 
 
 class AsyncBulkResource(AsyncAPIResource):
+    """
+    A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncBulkResourceWithRawResponse:
         """
diff --git a/src/knockapi/resources/schedules/schedules.py b/src/knockapi/resources/schedules/schedules.py
index 3dd5b3a2..b7376a26 100644
--- a/src/knockapi/resources/schedules/schedules.py
+++ b/src/knockapi/resources/schedules/schedules.py
@@ -46,8 +46,15 @@
 
 
 class SchedulesResource(SyncAPIResource):
+    """
+    A schedule is a per-recipient, timezone-aware configuration for when to invoke a workflow.
+    """
+
     @cached_property
     def bulk(self) -> BulkResource:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResource(self._client)
 
     @cached_property
@@ -338,8 +345,15 @@ def delete(
 
 
 class AsyncSchedulesResource(AsyncAPIResource):
+    """
+    A schedule is a per-recipient, timezone-aware configuration for when to invoke a workflow.
+    """
+
     @cached_property
     def bulk(self) -> AsyncBulkResource:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResource(self._client)
 
     @cached_property
@@ -650,6 +664,9 @@ def __init__(self, schedules: SchedulesResource) -> None:
 
     @cached_property
     def bulk(self) -> BulkResourceWithRawResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResourceWithRawResponse(self._schedules.bulk)
 
 
@@ -672,6 +689,9 @@ def __init__(self, schedules: AsyncSchedulesResource) -> None:
 
     @cached_property
     def bulk(self) -> AsyncBulkResourceWithRawResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResourceWithRawResponse(self._schedules.bulk)
 
 
@@ -694,6 +714,9 @@ def __init__(self, schedules: SchedulesResource) -> None:
 
     @cached_property
     def bulk(self) -> BulkResourceWithStreamingResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResourceWithStreamingResponse(self._schedules.bulk)
 
 
@@ -716,4 +739,7 @@ def __init__(self, schedules: AsyncSchedulesResource) -> None:
 
     @cached_property
     def bulk(self) -> AsyncBulkResourceWithStreamingResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResourceWithStreamingResponse(self._schedules.bulk)
diff --git a/src/knockapi/resources/tenants/bulk.py b/src/knockapi/resources/tenants/bulk.py
index e1c1087b..84a900fe 100644
--- a/src/knockapi/resources/tenants/bulk.py
+++ b/src/knockapi/resources/tenants/bulk.py
@@ -23,6 +23,10 @@
 
 
 class BulkResource(SyncAPIResource):
+    """
+    A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+    """
+
     @cached_property
     def with_raw_response(self) -> BulkResourceWithRawResponse:
         """
@@ -128,6 +132,10 @@ def set(
 
 
 class AsyncBulkResource(AsyncAPIResource):
+    """
+    A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncBulkResourceWithRawResponse:
         """
diff --git a/src/knockapi/resources/tenants/tenants.py b/src/knockapi/resources/tenants/tenants.py
index 492f541f..9fdee42f 100644
--- a/src/knockapi/resources/tenants/tenants.py
+++ b/src/knockapi/resources/tenants/tenants.py
@@ -34,8 +34,15 @@
 
 
 class TenantsResource(SyncAPIResource):
+    """
+    A tenant represents a top-level entity from your system, like a company, organization, account, or workspace.
+    """
+
     @cached_property
     def bulk(self) -> BulkResource:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResource(self._client)
 
     @cached_property
@@ -273,8 +280,15 @@ def set(
 
 
 class AsyncTenantsResource(AsyncAPIResource):
+    """
+    A tenant represents a top-level entity from your system, like a company, organization, account, or workspace.
+    """
+
     @cached_property
     def bulk(self) -> AsyncBulkResource:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResource(self._client)
 
     @cached_property
@@ -530,6 +544,9 @@ def __init__(self, tenants: TenantsResource) -> None:
 
     @cached_property
     def bulk(self) -> BulkResourceWithRawResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResourceWithRawResponse(self._tenants.bulk)
 
 
@@ -552,6 +569,9 @@ def __init__(self, tenants: AsyncTenantsResource) -> None:
 
     @cached_property
     def bulk(self) -> AsyncBulkResourceWithRawResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResourceWithRawResponse(self._tenants.bulk)
 
 
@@ -574,6 +594,9 @@ def __init__(self, tenants: TenantsResource) -> None:
 
     @cached_property
     def bulk(self) -> BulkResourceWithStreamingResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResourceWithStreamingResponse(self._tenants.bulk)
 
 
@@ -596,4 +619,7 @@ def __init__(self, tenants: AsyncTenantsResource) -> None:
 
     @cached_property
     def bulk(self) -> AsyncBulkResourceWithStreamingResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResourceWithStreamingResponse(self._tenants.bulk)
diff --git a/src/knockapi/resources/users/bulk.py b/src/knockapi/resources/users/bulk.py
index 3fa39426..48e4d621 100644
--- a/src/knockapi/resources/users/bulk.py
+++ b/src/knockapi/resources/users/bulk.py
@@ -26,6 +26,10 @@
 
 
 class BulkResource(SyncAPIResource):
+    """
+    A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+    """
+
     @cached_property
     def with_raw_response(self) -> BulkResourceWithRawResponse:
         """
@@ -187,6 +191,10 @@ def set_preferences(
 
 
 class AsyncBulkResource(AsyncAPIResource):
+    """
+    A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncBulkResourceWithRawResponse:
         """
diff --git a/src/knockapi/resources/users/feeds.py b/src/knockapi/resources/users/feeds.py
index 4f8201de..2ba95f7a 100644
--- a/src/knockapi/resources/users/feeds.py
+++ b/src/knockapi/resources/users/feeds.py
@@ -26,6 +26,11 @@
 
 
 class FeedsResource(SyncAPIResource):
+    """A user is an individual from your system, represented in Knock.
+
+    They are most commonly a recipient of a notification.
+    """
+
     @cached_property
     def with_raw_response(self) -> FeedsResourceWithRawResponse:
         """
@@ -206,6 +211,11 @@ def list_items(
 
 
 class AsyncFeedsResource(AsyncAPIResource):
+    """A user is an individual from your system, represented in Knock.
+
+    They are most commonly a recipient of a notification.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncFeedsResourceWithRawResponse:
         """
diff --git a/src/knockapi/resources/users/guides.py b/src/knockapi/resources/users/guides.py
index 06c493b2..c308b573 100644
--- a/src/knockapi/resources/users/guides.py
+++ b/src/knockapi/resources/users/guides.py
@@ -32,6 +32,11 @@
 
 
 class GuidesResource(SyncAPIResource):
+    """A user is an individual from your system, represented in Knock.
+
+    They are most commonly a recipient of a notification.
+    """
+
     @cached_property
     def with_raw_response(self) -> GuidesResourceWithRawResponse:
         """
@@ -364,6 +369,11 @@ def mark_message_as_seen(
 
 
 class AsyncGuidesResource(AsyncAPIResource):
+    """A user is an individual from your system, represented in Knock.
+
+    They are most commonly a recipient of a notification.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncGuidesResourceWithRawResponse:
         """
diff --git a/src/knockapi/resources/users/users.py b/src/knockapi/resources/users/users.py
index 842a66ff..c60bbc2f 100644
--- a/src/knockapi/resources/users/users.py
+++ b/src/knockapi/resources/users/users.py
@@ -71,16 +71,32 @@
 
 
 class UsersResource(SyncAPIResource):
+    """A user is an individual from your system, represented in Knock.
+
+    They are most commonly a recipient of a notification.
+    """
+
     @cached_property
     def feeds(self) -> FeedsResource:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         return FeedsResource(self._client)
 
     @cached_property
     def guides(self) -> GuidesResource:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         return GuidesResource(self._client)
 
     @cached_property
     def bulk(self) -> BulkResource:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResource(self._client)
 
     @cached_property
@@ -889,16 +905,32 @@ def unset_channel_data(
 
 
 class AsyncUsersResource(AsyncAPIResource):
+    """A user is an individual from your system, represented in Knock.
+
+    They are most commonly a recipient of a notification.
+    """
+
     @cached_property
     def feeds(self) -> AsyncFeedsResource:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         return AsyncFeedsResource(self._client)
 
     @cached_property
     def guides(self) -> AsyncGuidesResource:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         return AsyncGuidesResource(self._client)
 
     @cached_property
     def bulk(self) -> AsyncBulkResource:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResource(self._client)
 
     @cached_property
@@ -1757,14 +1789,25 @@ def __init__(self, users: UsersResource) -> None:
 
     @cached_property
     def feeds(self) -> FeedsResourceWithRawResponse:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         return FeedsResourceWithRawResponse(self._users.feeds)
 
     @cached_property
     def guides(self) -> GuidesResourceWithRawResponse:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         return GuidesResourceWithRawResponse(self._users.guides)
 
     @cached_property
     def bulk(self) -> BulkResourceWithRawResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResourceWithRawResponse(self._users.bulk)
 
 
@@ -1817,14 +1860,25 @@ def __init__(self, users: AsyncUsersResource) -> None:
 
     @cached_property
     def feeds(self) -> AsyncFeedsResourceWithRawResponse:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         return AsyncFeedsResourceWithRawResponse(self._users.feeds)
 
     @cached_property
     def guides(self) -> AsyncGuidesResourceWithRawResponse:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         return AsyncGuidesResourceWithRawResponse(self._users.guides)
 
     @cached_property
     def bulk(self) -> AsyncBulkResourceWithRawResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResourceWithRawResponse(self._users.bulk)
 
 
@@ -1877,14 +1931,25 @@ def __init__(self, users: UsersResource) -> None:
 
     @cached_property
     def feeds(self) -> FeedsResourceWithStreamingResponse:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         return FeedsResourceWithStreamingResponse(self._users.feeds)
 
     @cached_property
     def guides(self) -> GuidesResourceWithStreamingResponse:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         return GuidesResourceWithStreamingResponse(self._users.guides)
 
     @cached_property
     def bulk(self) -> BulkResourceWithStreamingResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return BulkResourceWithStreamingResponse(self._users.bulk)
 
 
@@ -1937,12 +2002,23 @@ def __init__(self, users: AsyncUsersResource) -> None:
 
     @cached_property
     def feeds(self) -> AsyncFeedsResourceWithStreamingResponse:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         return AsyncFeedsResourceWithStreamingResponse(self._users.feeds)
 
     @cached_property
     def guides(self) -> AsyncGuidesResourceWithStreamingResponse:
+        """A user is an individual from your system, represented in Knock.
+
+        They are most commonly a recipient of a notification.
+        """
         return AsyncGuidesResourceWithStreamingResponse(self._users.guides)
 
     @cached_property
     def bulk(self) -> AsyncBulkResourceWithStreamingResponse:
+        """
+        A bulk operation is a set of changes applied across zero or more records triggered via a call to the Knock API and performed asynchronously.
+        """
         return AsyncBulkResourceWithStreamingResponse(self._users.bulk)
diff --git a/src/knockapi/resources/workflows.py b/src/knockapi/resources/workflows.py
index 05418bbc..d6012ebd 100644
--- a/src/knockapi/resources/workflows.py
+++ b/src/knockapi/resources/workflows.py
@@ -27,6 +27,10 @@
 
 
 class WorkflowsResource(SyncAPIResource):
+    """
+    A workflow is a structured set of steps that is triggered to produce notifications sent over channels.
+    """
+
     @cached_property
     def with_raw_response(self) -> WorkflowsResourceWithRawResponse:
         """
@@ -188,6 +192,10 @@ def trigger(
 
 
 class AsyncWorkflowsResource(AsyncAPIResource):
+    """
+    A workflow is a structured set of steps that is triggered to produce notifications sent over channels.
+    """
+
     @cached_property
     def with_raw_response(self) -> AsyncWorkflowsResourceWithRawResponse:
         """