diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9e14395a..43283d95 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,12 +1,14 @@
 name: CI
 on:
   push:
-    branches-ignore:
-      - 'generated'
-      - 'codegen/**'
-      - 'integrated/**'
-      - 'stl-preview-head/**'
-      - 'stl-preview-base/**'
+    branches:
+      - '**'
+      - '!integrated/**'
+      - '!stl-preview-head/**'
+      - '!stl-preview-base/**'
+      - '!generated'
+      - '!codegen/**'
+      - 'codegen/stl/**'
   pull_request:
     branches-ignore:
       - 'stl-preview-head/**'
@@ -17,7 +19,7 @@ jobs:
     timeout-minutes: 10
     name: lint
     runs-on: ${{ github.repository == 'stainless-sdks/knock-python' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
-    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork
+    if: (github.event_name == 'push' || github.event.pull_request.head.repo.fork) && (github.event_name != 'push' || github.event.head_commit.message != 'codegen metadata')
     steps:
       - uses: actions/checkout@v6
 
@@ -36,7 +38,7 @@ jobs:
         run: ./scripts/lint
 
   build:
-    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork
+    if: (github.event_name == 'push' || github.event.pull_request.head.repo.fork) && (github.event_name != 'push' || github.event.head_commit.message != 'codegen metadata')
     timeout-minutes: 10
     name: build
     permissions:
diff --git a/.gitignore b/.gitignore
index 95ceb189..3824f4c4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 .prism.log
+.stdy.log
 _dev
 
 __pycache__
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 347a18e5..0c0c0c35 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +1,3 @@
 {
-  ".": "1.24.1"
+  ".": "1.25.0"
 }
\ No newline at end of file
diff --git a/.stats.yml b/.stats.yml
index 88ac15d5..86d162ea 100644
--- a/.stats.yml
+++ b/.stats.yml
@@ -1,4 +1,4 @@
-configured_endpoints: 90
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/knock%2Fknock-8453f7087b0207e02d485220151fc4eb2348689b4c281de0184cdc80f9a15c01.yml
-openapi_spec_hash: deda6ffd2fc6c4d79a556cb216811cc8
-config_hash: 32503026a45db991d0d102f25af40a77
+configured_endpoints: 94
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/knock%2Fknock-3e8f3a4664d48b3d546339018b451a356f8e20c223a2d21e7c3824fad4cddc7b.yml
+openapi_spec_hash: c2b6637451a63e39c1f1042c6a7cc7f7
+config_hash: 625db64572b7ee0ee1dd00546e53fc5f
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a8492e0f..ef3d5eae 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,58 @@
 # Changelog
 
+## 1.25.0 (2026-04-23)
+
+Full Changelog: [v1.24.1...v1.25.0](https://github.com/knocklabs/knock-python/compare/v1.24.1...v1.25.0)
+
+### Features
+
+* **api:** added new unset preferences methods ([519404b](https://github.com/knocklabs/knock-python/commit/519404bee37ce267e3e43ef65067c8172f95219f))
+* **api:** api update ([69bb5b7](https://github.com/knocklabs/knock-python/commit/69bb5b7b9aba93811ba0faee5b6a068332faf86e))
+* **api:** api update ([8d2a780](https://github.com/knocklabs/knock-python/commit/8d2a780c8ddbd78858570bb97a5907f34329d5fd))
+* **api:** api update ([f0c9120](https://github.com/knocklabs/knock-python/commit/f0c9120cefcd5905de5b0a208ae1bc5b35452acd))
+* **api:** api update ([5d9ba46](https://github.com/knocklabs/knock-python/commit/5d9ba46e6ab6200bba7d6a7fed0f87582b2ad34e))
+* **api:** skip tests for 2 endpoints in 2 languages ([a36266c](https://github.com/knocklabs/knock-python/commit/a36266c02d2574422a9f2f0d8b3de5b9a2ce8b17))
+* **internal:** implement indices array format for query and form serialization ([e7db532](https://github.com/knocklabs/knock-python/commit/e7db532103b42156c58ea021d78ae97f71b8c0bd))
+* **KNO-12791:** Add workflow recipient run APIs ([10be0e6](https://github.com/knocklabs/knock-python/commit/10be0e64f3623ac7e17c0db4fd1c6b45eb505ed5))
+
+
+### Bug Fixes
+
+* **client:** preserve hardcoded query params when merging with user params ([b94df51](https://github.com/knocklabs/knock-python/commit/b94df5190b4c56bc70d87a8d5c10817a5c6e4ba8))
+* **deps:** bump minimum typing-extensions version ([3faab94](https://github.com/knocklabs/knock-python/commit/3faab948d5ae4297d7c35150545d843e0c34f427))
+* ensure file data are only sent as 1 parameter ([05206e0](https://github.com/knocklabs/knock-python/commit/05206e0e5f9c871bd9dac1b14f457df734da26ed))
+* sanitize endpoint path params ([5615d9e](https://github.com/knocklabs/knock-python/commit/5615d9e295147ff3a2321ca06222d2f04c875e30))
+
+
+### Performance Improvements
+
+* **client:** optimize file structure copying in multipart requests ([b742a9f](https://github.com/knocklabs/knock-python/commit/b742a9fab9d76f56b6081fb6bc5a2b356676a67b))
+
+
+### Chores
+
+* **ci:** skip lint on metadata-only changes ([64c3c93](https://github.com/knocklabs/knock-python/commit/64c3c93d337ee63ea4b81c23bbefd9d7c12a7e7b))
+* **internal:** more robust bootstrap script ([6f7de4e](https://github.com/knocklabs/knock-python/commit/6f7de4e88c3f990e94753a8c347cc72a509acca0))
+* **internal:** tweak CI branches ([4c01647](https://github.com/knocklabs/knock-python/commit/4c016474b315185a18ec577ea79e0b3115607dd3))
+* **internal:** update gitignore ([e5e89f5](https://github.com/knocklabs/knock-python/commit/e5e89f5f97e9170e602a836907a68987756b82f8))
+* **tests:** bump steady to v0.19.4 ([1b211c0](https://github.com/knocklabs/knock-python/commit/1b211c0a547eff991969ddfb57418b9797cb5f10))
+* **tests:** bump steady to v0.19.5 ([a0638b5](https://github.com/knocklabs/knock-python/commit/a0638b570e32ab0db5028d1e5ab4f24da80bee7b))
+* **tests:** bump steady to v0.19.6 ([f09d000](https://github.com/knocklabs/knock-python/commit/f09d000d0185189f1134f655cf96f522c59dfd24))
+* **tests:** bump steady to v0.19.7 ([973f8be](https://github.com/knocklabs/knock-python/commit/973f8bec907c1b613f410dd36711d171d43e97ef))
+* **tests:** bump steady to v0.20.1 ([ddb0590](https://github.com/knocklabs/knock-python/commit/ddb05902d4de62871a6574566fcc263d97b5057c))
+* **tests:** bump steady to v0.20.2 ([17eac93](https://github.com/knocklabs/knock-python/commit/17eac9319d41e7978dc3b2e201bb843ad3eb7f23))
+* **tests:** bump steady to v0.22.1 ([726ca11](https://github.com/knocklabs/knock-python/commit/726ca11ad213e6b2c947ebf5931491dfdf440d01))
+
+
+### Documentation
+
+* improve examples ([c47c485](https://github.com/knocklabs/knock-python/commit/c47c4853030bb13ffc641094d76ef223507a884a))
+
+
+### Refactors
+
+* **tests:** switch from prism to steady ([29d5c77](https://github.com/knocklabs/knock-python/commit/29d5c776dae1ed8712a0d5514f48ee0fe6afda14))
+
 ## 1.24.1 (2026-03-16)
 
 Full Changelog: [v1.24.0...v1.24.1](https://github.com/knocklabs/knock-python/compare/v1.24.0...v1.24.1)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e12d6933..46ce97dc 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -85,7 +85,7 @@ $ pip install ./path-to-wheel-file.whl
 
 ## Running tests
 
-Most tests require you to [set up a mock server](https://github.com/stoplightio/prism) against the OpenAPI spec to run the tests.
+Most tests require you to [set up a mock server](https://github.com/dgellow/steady) against the OpenAPI spec to run the tests.
 
 ```sh
 $ ./scripts/mock
diff --git a/api.md b/api.md
index 139f276b..d1de9440 100644
--- a/api.md
+++ b/api.md
@@ -84,6 +84,7 @@ Methods:
 - <code title="put /v1/users/{user_id}/channel_data/{channel_id}">client.users.<a href="./src/knockapi/resources/users/users.py">set_channel_data</a>(user_id, channel_id, \*\*<a href="src/knockapi/types/user_set_channel_data_params.py">params</a>) -> <a href="./src/knockapi/types/recipients/channel_data.py">ChannelData</a></code>
 - <code title="put /v1/users/{user_id}/preferences/{id}">client.users.<a href="./src/knockapi/resources/users/users.py">set_preferences</a>(user_id, id, \*\*<a href="src/knockapi/types/user_set_preferences_params.py">params</a>) -> <a href="./src/knockapi/types/recipients/preference_set.py">PreferenceSet</a></code>
 - <code title="delete /v1/users/{user_id}/channel_data/{channel_id}">client.users.<a href="./src/knockapi/resources/users/users.py">unset_channel_data</a>(user_id, channel_id) -> None</code>
+- <code title="delete /v1/users/{user_id}/preferences/{id}">client.users.<a href="./src/knockapi/resources/users/users.py">unset_preferences</a>(user_id, id) -> None</code>
 
 ## Feeds
 
@@ -157,6 +158,7 @@ Methods:
 - <code title="put /v1/objects/{collection}/{object_id}/channel_data/{channel_id}">client.objects.<a href="./src/knockapi/resources/objects/objects.py">set_channel_data</a>(collection, object_id, channel_id, \*\*<a href="src/knockapi/types/object_set_channel_data_params.py">params</a>) -> <a href="./src/knockapi/types/recipients/channel_data.py">ChannelData</a></code>
 - <code title="put /v1/objects/{collection}/{object_id}/preferences/{id}">client.objects.<a href="./src/knockapi/resources/objects/objects.py">set_preferences</a>(collection, object_id, id, \*\*<a href="src/knockapi/types/object_set_preferences_params.py">params</a>) -> <a href="./src/knockapi/types/recipients/preference_set.py">PreferenceSet</a></code>
 - <code title="delete /v1/objects/{collection}/{object_id}/channel_data/{channel_id}">client.objects.<a href="./src/knockapi/resources/objects/objects.py">unset_channel_data</a>(collection, object_id, channel_id) -> None</code>
+- <code title="delete /v1/objects/{collection}/{object_id}/preferences/{id}">client.objects.<a href="./src/knockapi/resources/objects/objects.py">unset_preferences</a>(collection, object_id, id) -> None</code>
 
 ## Bulk
 
@@ -338,6 +340,23 @@ Methods:
 - <code title="post /v1/workflows/{key}/cancel">client.workflows.<a href="./src/knockapi/resources/workflows.py">cancel</a>(key, \*\*<a href="src/knockapi/types/workflow_cancel_params.py">params</a>) -> None</code>
 - <code title="post /v1/workflows/{key}/trigger">client.workflows.<a href="./src/knockapi/resources/workflows.py">trigger</a>(key, \*\*<a href="src/knockapi/types/workflow_trigger_params.py">params</a>) -> <a href="./src/knockapi/types/workflow_trigger_response.py">WorkflowTriggerResponse</a></code>
 
+# WorkflowRecipientRuns
+
+Types:
+
+```python
+from knockapi.types import (
+    WorkflowRecipientRun,
+    WorkflowRecipientRunDetail,
+    WorkflowRecipientRunEvent,
+)
+```
+
+Methods:
+
+- <code title="get /v1/workflow_recipient_runs">client.workflow_recipient_runs.<a href="./src/knockapi/resources/workflow_recipient_runs.py">list</a>(\*\*<a href="src/knockapi/types/workflow_recipient_run_list_params.py">params</a>) -> <a href="./src/knockapi/types/workflow_recipient_run.py">SyncItemsCursor[WorkflowRecipientRun]</a></code>
+- <code title="get /v1/workflow_recipient_runs/{id}">client.workflow_recipient_runs.<a href="./src/knockapi/resources/workflow_recipient_runs.py">get</a>(id) -> <a href="./src/knockapi/types/workflow_recipient_run_detail.py">WorkflowRecipientRunDetail</a></code>
+
 # Schedules
 
 Types:
diff --git a/pyproject.toml b/pyproject.toml
index 9e40cd66..e23661b5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "knockapi"
-version = "1.24.1"
+version = "1.25.0"
 description = "The official Python library for the knock API"
 dynamic = ["readme"]
 license = "Apache-2.0"
@@ -11,7 +11,7 @@ authors = [
 dependencies = [
   "httpx>=0.23.0, <1",
   "pydantic>=1.9.0, <3",
-  "typing-extensions>=4.10, <5",
+  "typing-extensions>=4.14, <5",
   "anyio>=3.5.0, <5",
   "distro>=1.7.0, <2",
   "sniffio",
diff --git a/scripts/bootstrap b/scripts/bootstrap
index b430fee3..fe8451e4 100755
--- a/scripts/bootstrap
+++ b/scripts/bootstrap
@@ -4,7 +4,7 @@ set -e
 
 cd "$(dirname "$0")/.."
 
-if [ -f "Brewfile" ] && [ "$(uname -s)" = "Darwin" ] && [ "$SKIP_BREW" != "1" ] && [ -t 0 ]; then
+if [ -f "Brewfile" ] && [ "$(uname -s)" = "Darwin" ] && [ "${SKIP_BREW:-}" != "1" ] && [ -t 0 ]; then
   brew bundle check >/dev/null 2>&1 || {
     echo -n "==> Install Homebrew dependencies? (y/N): "
     read -r response
diff --git a/scripts/mock b/scripts/mock
index bcf3b392..04d29019 100755
--- a/scripts/mock
+++ b/scripts/mock
@@ -19,34 +19,34 @@ fi
 
 echo "==> Starting mock server with URL ${URL}"
 
-# Run prism mock on the given spec
+# Run steady mock on the given spec
 if [ "$1" == "--daemon" ]; then
   # Pre-install the package so the download doesn't eat into the startup timeout
-  npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism --version
+  npm exec --package=@stdy/cli@0.22.1 -- steady --version
 
-  npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL" &> .prism.log &
+  npm exec --package=@stdy/cli@0.22.1 -- steady --host 127.0.0.1 -p 4010 --validator-query-array-format=brackets --validator-form-array-format=brackets --validator-query-object-format=brackets --validator-form-object-format=brackets "$URL" &> .stdy.log &
 
-  # Wait for server to come online (max 30s)
+  # Wait for server to come online via health endpoint (max 30s)
   echo -n "Waiting for server"
   attempts=0
-  while ! grep -q "✖  fatal\|Prism is listening" ".prism.log" ; do
+  while ! curl --silent --fail "http://127.0.0.1:4010/_x-steady/health" >/dev/null 2>&1; do
+    if ! kill -0 $! 2>/dev/null; then
+      echo
+      cat .stdy.log
+      exit 1
+    fi
     attempts=$((attempts + 1))
     if [ "$attempts" -ge 300 ]; then
       echo
-      echo "Timed out waiting for Prism server to start"
-      cat .prism.log
+      echo "Timed out waiting for Steady server to start"
+      cat .stdy.log
       exit 1
     fi
     echo -n "."
     sleep 0.1
   done
 
-  if grep -q "✖  fatal" ".prism.log"; then
-    cat .prism.log
-    exit 1
-  fi
-
   echo
 else
-  npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL"
+  npm exec --package=@stdy/cli@0.22.1 -- steady --host 127.0.0.1 -p 4010 --validator-query-array-format=brackets --validator-form-array-format=brackets --validator-query-object-format=brackets --validator-form-object-format=brackets "$URL"
 fi
diff --git a/scripts/test b/scripts/test
index dbeda2d2..7b05e44f 100755
--- a/scripts/test
+++ b/scripts/test
@@ -9,8 +9,8 @@ GREEN='\033[0;32m'
 YELLOW='\033[0;33m'
 NC='\033[0m' # No Color
 
-function prism_is_running() {
-  curl --silent "http://localhost:4010" >/dev/null 2>&1
+function steady_is_running() {
+  curl --silent "http://127.0.0.1:4010/_x-steady/health" >/dev/null 2>&1
 }
 
 kill_server_on_port() {
@@ -25,7 +25,7 @@ function is_overriding_api_base_url() {
   [ -n "$TEST_API_BASE_URL" ]
 }
 
-if ! is_overriding_api_base_url && ! prism_is_running ; then
+if ! is_overriding_api_base_url && ! steady_is_running ; then
   # When we exit this script, make sure to kill the background mock server process
   trap 'kill_server_on_port 4010' EXIT
 
@@ -36,19 +36,19 @@ fi
 if is_overriding_api_base_url ; then
   echo -e "${GREEN}✔ Running tests against ${TEST_API_BASE_URL}${NC}"
   echo
-elif ! prism_is_running ; then
-  echo -e "${RED}ERROR:${NC} The test suite will not run without a mock Prism server"
+elif ! steady_is_running ; then
+  echo -e "${RED}ERROR:${NC} The test suite will not run without a mock Steady server"
   echo -e "running against your OpenAPI spec."
   echo
   echo -e "To run the server, pass in the path or url of your OpenAPI"
-  echo -e "spec to the prism command:"
+  echo -e "spec to the steady command:"
   echo
-  echo -e "  \$ ${YELLOW}npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock path/to/your.openapi.yml${NC}"
+  echo -e "  \$ ${YELLOW}npm exec --package=@stdy/cli@0.22.1 -- steady path/to/your.openapi.yml --host 127.0.0.1 -p 4010 --validator-query-array-format=brackets --validator-form-array-format=brackets --validator-query-object-format=brackets --validator-form-object-format=brackets${NC}"
   echo
 
   exit 1
 else
-  echo -e "${GREEN}✔ Mock prism server is running with your OpenAPI spec${NC}"
+  echo -e "${GREEN}✔ Mock steady server is running with your OpenAPI spec${NC}"
   echo
 fi
 
diff --git a/src/knockapi/_base_client.py b/src/knockapi/_base_client.py
index 406fc8a2..c5c10434 100644
--- a/src/knockapi/_base_client.py
+++ b/src/knockapi/_base_client.py
@@ -540,6 +540,10 @@ def _build_request(
                 files = cast(HttpxRequestFiles, ForceMultipartDict())
 
         prepared_url = self._prepare_url(options.url)
+        # preserve hard-coded query params from the url
+        if params and prepared_url.query:
+            params = {**dict(prepared_url.params.items()), **params}
+            prepared_url = prepared_url.copy_with(raw_path=prepared_url.raw_path.split(b"?", 1)[0])
         if "_" in prepared_url.host:
             # work around https://github.com/encode/httpx/discussions/2880
             kwargs["extensions"] = {"sni_hostname": prepared_url.host.replace("_", "-")}
diff --git a/src/knockapi/_client.py b/src/knockapi/_client.py
index 772dbcad..6f3e90be 100644
--- a/src/knockapi/_client.py
+++ b/src/knockapi/_client.py
@@ -43,6 +43,7 @@
         workflows,
         integrations,
         bulk_operations,
+        workflow_recipient_runs,
     )
     from .resources.audiences import AudiencesResource, AsyncAudiencesResource
     from .resources.workflows import WorkflowsResource, AsyncWorkflowsResource
@@ -54,6 +55,7 @@
     from .resources.messages.messages import MessagesResource, AsyncMessagesResource
     from .resources.providers.providers import ProvidersResource, AsyncProvidersResource
     from .resources.schedules.schedules import SchedulesResource, AsyncSchedulesResource
+    from .resources.workflow_recipient_runs import WorkflowRecipientRunsResource, AsyncWorkflowRecipientRunsResource
     from .resources.integrations.integrations import IntegrationsResource, AsyncIntegrationsResource
 
 __all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Knock", "AsyncKnock", "Client", "AsyncClient"]
@@ -187,6 +189,15 @@ def workflows(self) -> WorkflowsResource:
 
         return WorkflowsResource(self)
 
+    @cached_property
+    def workflow_recipient_runs(self) -> WorkflowRecipientRunsResource:
+        """
+        A workflow run represents an individual execution of a workflow for a specific recipient.
+        """
+        from .resources.workflow_recipient_runs import WorkflowRecipientRunsResource
+
+        return WorkflowRecipientRunsResource(self)
+
     @cached_property
     def schedules(self) -> SchedulesResource:
         """
@@ -453,6 +464,15 @@ def workflows(self) -> AsyncWorkflowsResource:
 
         return AsyncWorkflowsResource(self)
 
+    @cached_property
+    def workflow_recipient_runs(self) -> AsyncWorkflowRecipientRunsResource:
+        """
+        A workflow run represents an individual execution of a workflow for a specific recipient.
+        """
+        from .resources.workflow_recipient_runs import AsyncWorkflowRecipientRunsResource
+
+        return AsyncWorkflowRecipientRunsResource(self)
+
     @cached_property
     def schedules(self) -> AsyncSchedulesResource:
         """
@@ -660,6 +680,15 @@ def workflows(self) -> workflows.WorkflowsResourceWithRawResponse:
 
         return WorkflowsResourceWithRawResponse(self._client.workflows)
 
+    @cached_property
+    def workflow_recipient_runs(self) -> workflow_recipient_runs.WorkflowRecipientRunsResourceWithRawResponse:
+        """
+        A workflow run represents an individual execution of a workflow for a specific recipient.
+        """
+        from .resources.workflow_recipient_runs import WorkflowRecipientRunsResourceWithRawResponse
+
+        return WorkflowRecipientRunsResourceWithRawResponse(self._client.workflow_recipient_runs)
+
     @cached_property
     def schedules(self) -> schedules.SchedulesResourceWithRawResponse:
         """
@@ -752,6 +781,15 @@ def workflows(self) -> workflows.AsyncWorkflowsResourceWithRawResponse:
 
         return AsyncWorkflowsResourceWithRawResponse(self._client.workflows)
 
+    @cached_property
+    def workflow_recipient_runs(self) -> workflow_recipient_runs.AsyncWorkflowRecipientRunsResourceWithRawResponse:
+        """
+        A workflow run represents an individual execution of a workflow for a specific recipient.
+        """
+        from .resources.workflow_recipient_runs import AsyncWorkflowRecipientRunsResourceWithRawResponse
+
+        return AsyncWorkflowRecipientRunsResourceWithRawResponse(self._client.workflow_recipient_runs)
+
     @cached_property
     def schedules(self) -> schedules.AsyncSchedulesResourceWithRawResponse:
         """
@@ -844,6 +882,15 @@ def workflows(self) -> workflows.WorkflowsResourceWithStreamingResponse:
 
         return WorkflowsResourceWithStreamingResponse(self._client.workflows)
 
+    @cached_property
+    def workflow_recipient_runs(self) -> workflow_recipient_runs.WorkflowRecipientRunsResourceWithStreamingResponse:
+        """
+        A workflow run represents an individual execution of a workflow for a specific recipient.
+        """
+        from .resources.workflow_recipient_runs import WorkflowRecipientRunsResourceWithStreamingResponse
+
+        return WorkflowRecipientRunsResourceWithStreamingResponse(self._client.workflow_recipient_runs)
+
     @cached_property
     def schedules(self) -> schedules.SchedulesResourceWithStreamingResponse:
         """
@@ -936,6 +983,17 @@ def workflows(self) -> workflows.AsyncWorkflowsResourceWithStreamingResponse:
 
         return AsyncWorkflowsResourceWithStreamingResponse(self._client.workflows)
 
+    @cached_property
+    def workflow_recipient_runs(
+        self,
+    ) -> workflow_recipient_runs.AsyncWorkflowRecipientRunsResourceWithStreamingResponse:
+        """
+        A workflow run represents an individual execution of a workflow for a specific recipient.
+        """
+        from .resources.workflow_recipient_runs import AsyncWorkflowRecipientRunsResourceWithStreamingResponse
+
+        return AsyncWorkflowRecipientRunsResourceWithStreamingResponse(self._client.workflow_recipient_runs)
+
     @cached_property
     def schedules(self) -> schedules.AsyncSchedulesResourceWithStreamingResponse:
         """
diff --git a/src/knockapi/_files.py b/src/knockapi/_files.py
index cc14c14f..0fdce17b 100644
--- a/src/knockapi/_files.py
+++ b/src/knockapi/_files.py
@@ -3,8 +3,8 @@
 import io
 import os
 import pathlib
-from typing import overload
-from typing_extensions import TypeGuard
+from typing import Sequence, cast, overload
+from typing_extensions import TypeVar, TypeGuard
 
 import anyio
 
@@ -17,7 +17,9 @@
     HttpxFileContent,
     HttpxRequestFiles,
 )
-from ._utils import is_tuple_t, is_mapping_t, is_sequence_t
+from ._utils import is_list, is_mapping, is_tuple_t, is_mapping_t, is_sequence_t
+
+_T = TypeVar("_T")
 
 
 def is_base64_file_input(obj: object) -> TypeGuard[Base64FileInput]:
@@ -121,3 +123,51 @@ async def async_read_file_content(file: FileContent) -> HttpxFileContent:
         return await anyio.Path(file).read_bytes()
 
     return file
+
+
+def deepcopy_with_paths(item: _T, paths: Sequence[Sequence[str]]) -> _T:
+    """Copy only the containers along the given paths.
+
+    Used to guard against mutation by extract_files without copying the entire structure.
+    Only dicts and lists that lie on a path are copied; everything else
+    is returned by reference.
+
+    For example, given paths=[["foo", "files", "file"]] and the structure:
+        {
+            "foo": {
+                "bar": {"baz": {}},
+                "files": {"file": <content>}
+            }
+        }
+    The root dict, "foo", and "files" are copied (they lie on the path).
+    "bar" and "baz" are returned by reference (off the path).
+    """
+    return _deepcopy_with_paths(item, paths, 0)
+
+
+def _deepcopy_with_paths(item: _T, paths: Sequence[Sequence[str]], index: int) -> _T:
+    if not paths:
+        return item
+    if is_mapping(item):
+        key_to_paths: dict[str, list[Sequence[str]]] = {}
+        for path in paths:
+            if index < len(path):
+                key_to_paths.setdefault(path[index], []).append(path)
+
+        # if no path continues through this mapping, it won't be mutated and copying it is redundant
+        if not key_to_paths:
+            return item
+
+        result = dict(item)
+        for key, subpaths in key_to_paths.items():
+            if key in result:
+                result[key] = _deepcopy_with_paths(result[key], subpaths, index + 1)
+        return cast(_T, result)
+    if is_list(item):
+        array_paths = [path for path in paths if index < len(path) and path[index] == "<array>"]
+
+        # if no path expects a list here, nothing will be mutated inside it - return by reference
+        if not array_paths:
+            return cast(_T, item)
+        return cast(_T, [_deepcopy_with_paths(entry, array_paths, index + 1) for entry in item])
+    return item
diff --git a/src/knockapi/_qs.py b/src/knockapi/_qs.py
index ada6fd3f..de8c99bc 100644
--- a/src/knockapi/_qs.py
+++ b/src/knockapi/_qs.py
@@ -101,7 +101,10 @@ def _stringify_item(
                     items.extend(self._stringify_item(key, item, opts))
                 return items
             elif array_format == "indices":
-                raise NotImplementedError("The array indices format is not supported yet")
+                items = []
+                for i, item in enumerate(value):
+                    items.extend(self._stringify_item(f"{key}[{i}]", item, opts))
+                return items
             elif array_format == "brackets":
                 items = []
                 key = key + "[]"
diff --git a/src/knockapi/_utils/__init__.py b/src/knockapi/_utils/__init__.py
index dc64e29a..1c090e51 100644
--- a/src/knockapi/_utils/__init__.py
+++ b/src/knockapi/_utils/__init__.py
@@ -1,3 +1,4 @@
+from ._path import path_template as path_template
 from ._sync import asyncify as asyncify
 from ._proxy import LazyProxy as LazyProxy
 from ._utils import (
@@ -23,7 +24,6 @@
     coerce_integer as coerce_integer,
     file_from_path as file_from_path,
     strip_not_given as strip_not_given,
-    deepcopy_minimal as deepcopy_minimal,
     get_async_library as get_async_library,
     maybe_coerce_float as maybe_coerce_float,
     get_required_header as get_required_header,
diff --git a/src/knockapi/_utils/_path.py b/src/knockapi/_utils/_path.py
new file mode 100644
index 00000000..4d6e1e4c
--- /dev/null
+++ b/src/knockapi/_utils/_path.py
@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import re
+from typing import (
+    Any,
+    Mapping,
+    Callable,
+)
+from urllib.parse import quote
+
+# Matches '.' or '..' where each dot is either literal or percent-encoded (%2e / %2E).
+_DOT_SEGMENT_RE = re.compile(r"^(?:\.|%2[eE]){1,2}$")
+
+_PLACEHOLDER_RE = re.compile(r"\{(\w+)\}")
+
+
+def _quote_path_segment_part(value: str) -> str:
+    """Percent-encode `value` for use in a URI path segment.
+
+    Considers characters not in `pchar` set from RFC 3986 §3.3 to be unsafe.
+    https://datatracker.ietf.org/doc/html/rfc3986#section-3.3
+    """
+    # quote() already treats unreserved characters (letters, digits, and -._~)
+    # as safe, so we only need to add sub-delims, ':', and '@'.
+    # Notably, unlike the default `safe` for quote(), / is unsafe and must be quoted.
+    return quote(value, safe="!$&'()*+,;=:@")
+
+
+def _quote_query_part(value: str) -> str:
+    """Percent-encode `value` for use in a URI query string.
+
+    Considers &, = and characters not in `query` set from RFC 3986 §3.4 to be unsafe.
+    https://datatracker.ietf.org/doc/html/rfc3986#section-3.4
+    """
+    return quote(value, safe="!$'()*+,;:@/?")
+
+
+def _quote_fragment_part(value: str) -> str:
+    """Percent-encode `value` for use in a URI fragment.
+
+    Considers characters not in `fragment` set from RFC 3986 §3.5 to be unsafe.
+    https://datatracker.ietf.org/doc/html/rfc3986#section-3.5
+    """
+    return quote(value, safe="!$&'()*+,;=:@/?")
+
+
+def _interpolate(
+    template: str,
+    values: Mapping[str, Any],
+    quoter: Callable[[str], str],
+) -> str:
+    """Replace {name} placeholders in `template`, quoting each value with `quoter`.
+
+    Placeholder names are looked up in `values`.
+
+    Raises:
+        KeyError: If a placeholder is not found in `values`.
+    """
+    # re.split with a capturing group returns alternating
+    # [text, name, text, name, ..., text] elements.
+    parts = _PLACEHOLDER_RE.split(template)
+
+    for i in range(1, len(parts), 2):
+        name = parts[i]
+        if name not in values:
+            raise KeyError(f"a value for placeholder {{{name}}} was not provided")
+        val = values[name]
+        if val is None:
+            parts[i] = "null"
+        elif isinstance(val, bool):
+            parts[i] = "true" if val else "false"
+        else:
+            parts[i] = quoter(str(values[name]))
+
+    return "".join(parts)
+
+
+def path_template(template: str, /, **kwargs: Any) -> str:
+    """Interpolate {name} placeholders in `template` from keyword arguments.
+
+    Args:
+        template: The template string containing {name} placeholders.
+        **kwargs: Keyword arguments to interpolate into the template.
+
+    Returns:
+        The template with placeholders interpolated and percent-encoded.
+
+        Safe characters for percent-encoding are dependent on the URI component.
+        Placeholders in path and fragment portions are percent-encoded where the `segment`
+        and `fragment` sets from RFC 3986 respectively are considered safe.
+        Placeholders in the query portion are percent-encoded where the `query` set from
+        RFC 3986 §3.3 is considered safe except for = and & characters.
+
+    Raises:
+        KeyError: If a placeholder is not found in `kwargs`.
+        ValueError: If resulting path contains /./ or /../ segments (including percent-encoded dot-segments).
+    """
+    # Split the template into path, query, and fragment portions.
+    fragment_template: str | None = None
+    query_template: str | None = None
+
+    rest = template
+    if "#" in rest:
+        rest, fragment_template = rest.split("#", 1)
+    if "?" in rest:
+        rest, query_template = rest.split("?", 1)
+    path_template = rest
+
+    # Interpolate each portion with the appropriate quoting rules.
+    path_result = _interpolate(path_template, kwargs, _quote_path_segment_part)
+
+    # Reject dot-segments (. and ..) in the final assembled path.  The check
+    # runs after interpolation so that adjacent placeholders or a mix of static
+    # text and placeholders that together form a dot-segment are caught.
+    # Also reject percent-encoded dot-segments to protect against incorrectly
+    # implemented normalization in servers/proxies.
+    for segment in path_result.split("/"):
+        if _DOT_SEGMENT_RE.match(segment):
+            raise ValueError(f"Constructed path {path_result!r} contains dot-segment {segment!r} which is not allowed")
+
+    result = path_result
+    if query_template is not None:
+        result += "?" + _interpolate(query_template, kwargs, _quote_query_part)
+    if fragment_template is not None:
+        result += "#" + _interpolate(fragment_template, kwargs, _quote_fragment_part)
+
+    return result
diff --git a/src/knockapi/_utils/_utils.py b/src/knockapi/_utils/_utils.py
index eec7f4a1..771859f5 100644
--- a/src/knockapi/_utils/_utils.py
+++ b/src/knockapi/_utils/_utils.py
@@ -86,8 +86,9 @@ def _extract_items(
     index += 1
     if is_dict(obj):
         try:
-            # We are at the last entry in the path so we must remove the field
-            if (len(path)) == index:
+            # Remove the field if there are no more dict keys in the path,
+            # only "<array>" traversal markers or end.
+            if all(p == "<array>" for p in path[index:]):
                 item = obj.pop(key)
             else:
                 item = obj[key]
@@ -176,21 +177,6 @@ def is_iterable(obj: object) -> TypeGuard[Iterable[object]]:
     return isinstance(obj, Iterable)
 
 
-def deepcopy_minimal(item: _T) -> _T:
-    """Minimal reimplementation of copy.deepcopy() that will only copy certain object types:
-
-    - mappings, e.g. `dict`
-    - list
-
-    This is done for performance reasons.
-    """
-    if is_mapping(item):
-        return cast(_T, {k: deepcopy_minimal(v) for k, v in item.items()})
-    if is_list(item):
-        return cast(_T, [deepcopy_minimal(entry) for entry in item])
-    return item
-
-
 # copied from https://github.com/Rapptz/RoboDanny
 def human_join(seq: Sequence[str], *, delim: str = ", ", final: str = "or") -> str:
     size = len(seq)
diff --git a/src/knockapi/_version.py b/src/knockapi/_version.py
index b7dec2ee..083c80ae 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.24.1"  # x-release-please-version
+__version__ = "1.25.0"  # x-release-please-version
diff --git a/src/knockapi/resources/__init__.py b/src/knockapi/resources/__init__.py
index 1630dbfe..7d1e158a 100644
--- a/src/knockapi/resources/__init__.py
+++ b/src/knockapi/resources/__init__.py
@@ -88,6 +88,14 @@
     BulkOperationsResourceWithStreamingResponse,
     AsyncBulkOperationsResourceWithStreamingResponse,
 )
+from .workflow_recipient_runs import (
+    WorkflowRecipientRunsResource,
+    AsyncWorkflowRecipientRunsResource,
+    WorkflowRecipientRunsResourceWithRawResponse,
+    AsyncWorkflowRecipientRunsResourceWithRawResponse,
+    WorkflowRecipientRunsResourceWithStreamingResponse,
+    AsyncWorkflowRecipientRunsResourceWithStreamingResponse,
+)
 
 __all__ = [
     "UsersResource",
@@ -138,6 +146,12 @@
     "AsyncWorkflowsResourceWithRawResponse",
     "WorkflowsResourceWithStreamingResponse",
     "AsyncWorkflowsResourceWithStreamingResponse",
+    "WorkflowRecipientRunsResource",
+    "AsyncWorkflowRecipientRunsResource",
+    "WorkflowRecipientRunsResourceWithRawResponse",
+    "AsyncWorkflowRecipientRunsResourceWithRawResponse",
+    "WorkflowRecipientRunsResourceWithStreamingResponse",
+    "AsyncWorkflowRecipientRunsResourceWithStreamingResponse",
     "SchedulesResource",
     "AsyncSchedulesResource",
     "SchedulesResourceWithRawResponse",
diff --git a/src/knockapi/resources/audiences.py b/src/knockapi/resources/audiences.py
index 2ab417d9..f592f67a 100644
--- a/src/knockapi/resources/audiences.py
+++ b/src/knockapi/resources/audiences.py
@@ -8,7 +8,7 @@
 
 from ..types import audience_add_members_params, audience_remove_members_params
 from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given
-from .._utils import maybe_transform, async_maybe_transform
+from .._utils import path_template, maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -81,7 +81,7 @@ def add_members(
             raise ValueError(f"Expected a non-empty value for `key` but received {key!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return self._post(
-            f"/v1/audiences/{key}/members",
+            path_template("/v1/audiences/{key}/members", key=key),
             body=maybe_transform({"members": members}, audience_add_members_params.AudienceAddMembersParams),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -122,7 +122,7 @@ def list_members(
         if not key:
             raise ValueError(f"Expected a non-empty value for `key` but received {key!r}")
         return self._get(
-            f"/v1/audiences/{key}/members",
+            path_template("/v1/audiences/{key}/members", key=key),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -163,7 +163,7 @@ def remove_members(
             raise ValueError(f"Expected a non-empty value for `key` but received {key!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return self._delete(
-            f"/v1/audiences/{key}/members",
+            path_template("/v1/audiences/{key}/members", key=key),
             body=maybe_transform({"members": members}, audience_remove_members_params.AudienceRemoveMembersParams),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -234,7 +234,7 @@ async def add_members(
             raise ValueError(f"Expected a non-empty value for `key` but received {key!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return await self._post(
-            f"/v1/audiences/{key}/members",
+            path_template("/v1/audiences/{key}/members", key=key),
             body=await async_maybe_transform(
                 {"members": members}, audience_add_members_params.AudienceAddMembersParams
             ),
@@ -277,7 +277,7 @@ async def list_members(
         if not key:
             raise ValueError(f"Expected a non-empty value for `key` but received {key!r}")
         return await self._get(
-            f"/v1/audiences/{key}/members",
+            path_template("/v1/audiences/{key}/members", key=key),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -318,7 +318,7 @@ async def remove_members(
             raise ValueError(f"Expected a non-empty value for `key` but received {key!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return await self._delete(
-            f"/v1/audiences/{key}/members",
+            path_template("/v1/audiences/{key}/members", key=key),
             body=await async_maybe_transform(
                 {"members": members}, audience_remove_members_params.AudienceRemoveMembersParams
             ),
diff --git a/src/knockapi/resources/bulk_operations.py b/src/knockapi/resources/bulk_operations.py
index 1cf6d595..02246ffe 100644
--- a/src/knockapi/resources/bulk_operations.py
+++ b/src/knockapi/resources/bulk_operations.py
@@ -5,6 +5,7 @@
 import httpx
 
 from .._types import Body, Query, Headers, NotGiven, not_given
+from .._utils import path_template
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -69,7 +70,7 @@ def get(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get(
-            f"/v1/bulk_operations/{id}",
+            path_template("/v1/bulk_operations/{id}", id=id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -127,7 +128,7 @@ async def get(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._get(
-            f"/v1/bulk_operations/{id}",
+            path_template("/v1/bulk_operations/{id}", id=id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
diff --git a/src/knockapi/resources/channels/bulk.py b/src/knockapi/resources/channels/bulk.py
index db127642..f9658346 100644
--- a/src/knockapi/resources/channels/bulk.py
+++ b/src/knockapi/resources/channels/bulk.py
@@ -9,7 +9,7 @@
 import httpx
 
 from ..._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
-from ..._utils import maybe_transform, async_maybe_transform
+from ..._utils import path_template, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -125,7 +125,7 @@ def update_message_status(
         if not action:
             raise ValueError(f"Expected a non-empty value for `action` but received {action!r}")
         return self._post(
-            f"/v1/channels/{channel_id}/messages/bulk/{action}",
+            path_template("/v1/channels/{channel_id}/messages/bulk/{action}", channel_id=channel_id, action=action),
             body=maybe_transform(
                 {
                     "archived": archived,
@@ -252,7 +252,7 @@ async def update_message_status(
         if not action:
             raise ValueError(f"Expected a non-empty value for `action` but received {action!r}")
         return await self._post(
-            f"/v1/channels/{channel_id}/messages/bulk/{action}",
+            path_template("/v1/channels/{channel_id}/messages/bulk/{action}", channel_id=channel_id, action=action),
             body=await async_maybe_transform(
                 {
                     "archived": archived,
diff --git a/src/knockapi/resources/messages/messages.py b/src/knockapi/resources/messages/messages.py
index 1e6c70c8..daf1ffef 100644
--- a/src/knockapi/resources/messages/messages.py
+++ b/src/knockapi/resources/messages/messages.py
@@ -23,7 +23,7 @@
     message_mark_as_interacted_params,
 )
 from ..._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
-from ..._utils import maybe_transform, async_maybe_transform
+from ..._utils import path_template, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -202,7 +202,7 @@ def archive(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._put(
-            f"/v1/messages/{message_id}/archived",
+            path_template("/v1/messages/{message_id}/archived", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -239,7 +239,7 @@ def get(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._get(
-            f"/v1/messages/{message_id}",
+            path_template("/v1/messages/{message_id}", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -273,7 +273,7 @@ def get_content(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._get(
-            f"/v1/messages/{message_id}/content",
+            path_template("/v1/messages/{message_id}/content", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -318,7 +318,7 @@ def list_activities(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._get_api_list(
-            f"/v1/messages/{message_id}/activities",
+            path_template("/v1/messages/{message_id}/activities", message_id=message_id),
             page=SyncItemsCursor[Activity],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -373,7 +373,7 @@ def list_delivery_logs(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._get_api_list(
-            f"/v1/messages/{message_id}/delivery_logs",
+            path_template("/v1/messages/{message_id}/delivery_logs", message_id=message_id),
             page=SyncItemsCursor[MessageDeliveryLog],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -427,7 +427,7 @@ def list_events(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._get_api_list(
-            f"/v1/messages/{message_id}/events",
+            path_template("/v1/messages/{message_id}/events", message_id=message_id),
             page=SyncItemsCursor[MessageEvent],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -483,7 +483,7 @@ def mark_as_interacted(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._put(
-            f"/v1/messages/{message_id}/interacted",
+            path_template("/v1/messages/{message_id}/interacted", message_id=message_id),
             body=maybe_transform(
                 {"metadata": metadata}, message_mark_as_interacted_params.MessageMarkAsInteractedParams
             ),
@@ -529,7 +529,7 @@ def mark_as_read(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._put(
-            f"/v1/messages/{message_id}/read",
+            path_template("/v1/messages/{message_id}/read", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -572,7 +572,7 @@ def mark_as_seen(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._put(
-            f"/v1/messages/{message_id}/seen",
+            path_template("/v1/messages/{message_id}/seen", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -615,7 +615,7 @@ def mark_as_unread(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._delete(
-            f"/v1/messages/{message_id}/read",
+            path_template("/v1/messages/{message_id}/read", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -658,7 +658,7 @@ def mark_as_unseen(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._delete(
-            f"/v1/messages/{message_id}/seen",
+            path_template("/v1/messages/{message_id}/seen", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -699,7 +699,7 @@ def unarchive(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._delete(
-            f"/v1/messages/{message_id}/archived",
+            path_template("/v1/messages/{message_id}/archived", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -870,7 +870,7 @@ async def archive(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return await self._put(
-            f"/v1/messages/{message_id}/archived",
+            path_template("/v1/messages/{message_id}/archived", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -907,7 +907,7 @@ async def get(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return await self._get(
-            f"/v1/messages/{message_id}",
+            path_template("/v1/messages/{message_id}", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -941,7 +941,7 @@ async def get_content(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return await self._get(
-            f"/v1/messages/{message_id}/content",
+            path_template("/v1/messages/{message_id}/content", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -986,7 +986,7 @@ def list_activities(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._get_api_list(
-            f"/v1/messages/{message_id}/activities",
+            path_template("/v1/messages/{message_id}/activities", message_id=message_id),
             page=AsyncItemsCursor[Activity],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1041,7 +1041,7 @@ def list_delivery_logs(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._get_api_list(
-            f"/v1/messages/{message_id}/delivery_logs",
+            path_template("/v1/messages/{message_id}/delivery_logs", message_id=message_id),
             page=AsyncItemsCursor[MessageDeliveryLog],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1095,7 +1095,7 @@ def list_events(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._get_api_list(
-            f"/v1/messages/{message_id}/events",
+            path_template("/v1/messages/{message_id}/events", message_id=message_id),
             page=AsyncItemsCursor[MessageEvent],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1151,7 +1151,7 @@ async def mark_as_interacted(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return await self._put(
-            f"/v1/messages/{message_id}/interacted",
+            path_template("/v1/messages/{message_id}/interacted", message_id=message_id),
             body=await async_maybe_transform(
                 {"metadata": metadata}, message_mark_as_interacted_params.MessageMarkAsInteractedParams
             ),
@@ -1197,7 +1197,7 @@ async def mark_as_read(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return await self._put(
-            f"/v1/messages/{message_id}/read",
+            path_template("/v1/messages/{message_id}/read", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -1240,7 +1240,7 @@ async def mark_as_seen(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return await self._put(
-            f"/v1/messages/{message_id}/seen",
+            path_template("/v1/messages/{message_id}/seen", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -1283,7 +1283,7 @@ async def mark_as_unread(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return await self._delete(
-            f"/v1/messages/{message_id}/read",
+            path_template("/v1/messages/{message_id}/read", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -1326,7 +1326,7 @@ async def mark_as_unseen(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return await self._delete(
-            f"/v1/messages/{message_id}/seen",
+            path_template("/v1/messages/{message_id}/seen", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -1367,7 +1367,7 @@ async def unarchive(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return await self._delete(
-            f"/v1/messages/{message_id}/archived",
+            path_template("/v1/messages/{message_id}/archived", message_id=message_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
diff --git a/src/knockapi/resources/objects/bulk.py b/src/knockapi/resources/objects/bulk.py
index de559248..e19fd411 100644
--- a/src/knockapi/resources/objects/bulk.py
+++ b/src/knockapi/resources/objects/bulk.py
@@ -7,7 +7,7 @@
 import httpx
 
 from ..._types import Body, Query, Headers, NotGiven, SequenceNotStr, not_given
-from ..._utils import maybe_transform, async_maybe_transform
+from ..._utils import path_template, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -84,7 +84,7 @@ def delete(
         if not collection:
             raise ValueError(f"Expected a non-empty value for `collection` but received {collection!r}")
         return self._post(
-            f"/v1/objects/{collection}/bulk/delete",
+            path_template("/v1/objects/{collection}/bulk/delete", collection=collection),
             body=maybe_transform({"object_ids": object_ids}, bulk_delete_params.BulkDeleteParams),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -133,7 +133,7 @@ def add_subscriptions(
         if not collection:
             raise ValueError(f"Expected a non-empty value for `collection` but received {collection!r}")
         return self._post(
-            f"/v1/objects/{collection}/bulk/subscriptions/add",
+            path_template("/v1/objects/{collection}/bulk/subscriptions/add", collection=collection),
             body=maybe_transform(
                 {"subscriptions": subscriptions}, bulk_add_subscriptions_params.BulkAddSubscriptionsParams
             ),
@@ -181,7 +181,7 @@ def delete_subscriptions(
         if not collection:
             raise ValueError(f"Expected a non-empty value for `collection` but received {collection!r}")
         return self._post(
-            f"/v1/objects/{collection}/bulk/subscriptions/delete",
+            path_template("/v1/objects/{collection}/bulk/subscriptions/delete", collection=collection),
             body=maybe_transform(
                 {"subscriptions": subscriptions}, bulk_delete_subscriptions_params.BulkDeleteSubscriptionsParams
             ),
@@ -227,7 +227,7 @@ def set(
         if not collection:
             raise ValueError(f"Expected a non-empty value for `collection` but received {collection!r}")
         return self._post(
-            f"/v1/objects/{collection}/bulk/set",
+            path_template("/v1/objects/{collection}/bulk/set", collection=collection),
             body=maybe_transform({"objects": objects}, bulk_set_params.BulkSetParams),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -296,7 +296,7 @@ async def delete(
         if not collection:
             raise ValueError(f"Expected a non-empty value for `collection` but received {collection!r}")
         return await self._post(
-            f"/v1/objects/{collection}/bulk/delete",
+            path_template("/v1/objects/{collection}/bulk/delete", collection=collection),
             body=await async_maybe_transform({"object_ids": object_ids}, bulk_delete_params.BulkDeleteParams),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -345,7 +345,7 @@ async def add_subscriptions(
         if not collection:
             raise ValueError(f"Expected a non-empty value for `collection` but received {collection!r}")
         return await self._post(
-            f"/v1/objects/{collection}/bulk/subscriptions/add",
+            path_template("/v1/objects/{collection}/bulk/subscriptions/add", collection=collection),
             body=await async_maybe_transform(
                 {"subscriptions": subscriptions}, bulk_add_subscriptions_params.BulkAddSubscriptionsParams
             ),
@@ -393,7 +393,7 @@ async def delete_subscriptions(
         if not collection:
             raise ValueError(f"Expected a non-empty value for `collection` but received {collection!r}")
         return await self._post(
-            f"/v1/objects/{collection}/bulk/subscriptions/delete",
+            path_template("/v1/objects/{collection}/bulk/subscriptions/delete", collection=collection),
             body=await async_maybe_transform(
                 {"subscriptions": subscriptions}, bulk_delete_subscriptions_params.BulkDeleteSubscriptionsParams
             ),
@@ -439,7 +439,7 @@ async def set(
         if not collection:
             raise ValueError(f"Expected a non-empty value for `collection` but received {collection!r}")
         return await self._post(
-            f"/v1/objects/{collection}/bulk/set",
+            path_template("/v1/objects/{collection}/bulk/set", collection=collection),
             body=await async_maybe_transform({"objects": objects}, bulk_set_params.BulkSetParams),
             options=make_request_options(
                 extra_headers=extra_headers,
diff --git a/src/knockapi/resources/objects/objects.py b/src/knockapi/resources/objects/objects.py
index 96c7bc1e..8a3ef845 100644
--- a/src/knockapi/resources/objects/objects.py
+++ b/src/knockapi/resources/objects/objects.py
@@ -27,7 +27,7 @@
     object_delete_subscriptions_params,
 )
 from ..._types import Body, Omit, Query, Headers, NoneType, NotGiven, SequenceNotStr, omit, not_given
-from ..._utils import maybe_transform, async_maybe_transform
+from ..._utils import path_template, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -125,7 +125,7 @@ def list(
         if not collection:
             raise ValueError(f"Expected a non-empty value for `collection` but received {collection!r}")
         return self._get_api_list(
-            f"/v1/objects/{collection}",
+            path_template("/v1/objects/{collection}", collection=collection),
             page=SyncEntriesCursor[Object],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -180,7 +180,7 @@ def delete(
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return self._delete(
-            f"/v1/objects/{collection}/{id}",
+            path_template("/v1/objects/{collection}/{id}", collection=collection, id=id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -234,7 +234,9 @@ def add_subscriptions(
         if not object_id:
             raise ValueError(f"Expected a non-empty value for `object_id` but received {object_id!r}")
         return self._post(
-            f"/v1/objects/{collection}/{object_id}/subscriptions",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/subscriptions", collection=collection, object_id=object_id
+            ),
             body=maybe_transform(
                 {
                     "recipients": recipients,
@@ -290,7 +292,9 @@ def delete_subscriptions(
         if not object_id:
             raise ValueError(f"Expected a non-empty value for `object_id` but received {object_id!r}")
         return self._delete(
-            f"/v1/objects/{collection}/{object_id}/subscriptions",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/subscriptions", collection=collection, object_id=object_id
+            ),
             body=maybe_transform(
                 {"recipients": recipients}, object_delete_subscriptions_params.ObjectDeleteSubscriptionsParams
             ),
@@ -335,7 +339,7 @@ def get(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get(
-            f"/v1/objects/{collection}/{id}",
+            path_template("/v1/objects/{collection}/{id}", collection=collection, id=id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -374,7 +378,12 @@ def get_channel_data(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._get(
-            f"/v1/objects/{collection}/{object_id}/channel_data/{channel_id}",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/channel_data/{channel_id}",
+                collection=collection,
+                object_id=object_id,
+                channel_id=channel_id,
+            ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -413,7 +422,12 @@ def get_preferences(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get(
-            f"/v1/objects/{collection}/{object_id}/preferences/{id}",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/preferences/{id}",
+                collection=collection,
+                object_id=object_id,
+                id=id,
+            ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -499,7 +513,7 @@ def list_messages(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get_api_list(
-            f"/v1/objects/{collection}/{id}/messages",
+            path_template("/v1/objects/{collection}/{id}/messages", collection=collection, id=id),
             page=SyncItemsCursor[Message],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -558,7 +572,9 @@ def list_preferences(
         if not object_id:
             raise ValueError(f"Expected a non-empty value for `object_id` but received {object_id!r}")
         return self._get(
-            f"/v1/objects/{collection}/{object_id}/preferences",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/preferences", collection=collection, object_id=object_id
+            ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -609,7 +625,7 @@ def list_schedules(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get_api_list(
-            f"/v1/objects/{collection}/{id}/schedules",
+            path_template("/v1/objects/{collection}/{id}/schedules", collection=collection, id=id),
             page=SyncEntriesCursor[Schedule],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -685,7 +701,9 @@ def list_subscriptions(
         if not object_id:
             raise ValueError(f"Expected a non-empty value for `object_id` but received {object_id!r}")
         return self._get_api_list(
-            f"/v1/objects/{collection}/{object_id}/subscriptions",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/subscriptions", collection=collection, object_id=object_id
+            ),
             page=SyncEntriesCursor[Subscription],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -763,7 +781,7 @@ def set(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._put(
-            f"/v1/objects/{collection}/{id}",
+            path_template("/v1/objects/{collection}/{id}", collection=collection, id=id),
             body=maybe_transform(
                 {
                     "channel_data": channel_data,
@@ -825,7 +843,12 @@ def set_channel_data(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._put(
-            f"/v1/objects/{collection}/{object_id}/channel_data/{channel_id}",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/channel_data/{channel_id}",
+                collection=collection,
+                object_id=object_id,
+                channel_id=channel_id,
+            ),
             body=maybe_transform({"data": data}, object_set_channel_data_params.ObjectSetChannelDataParams),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -902,7 +925,12 @@ def set_preferences(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._put(
-            f"/v1/objects/{collection}/{object_id}/preferences/{id}",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/preferences/{id}",
+                collection=collection,
+                object_id=object_id,
+                id=id,
+            ),
             body=maybe_transform(
                 {
                     "_persistence_strategy": _persistence_strategy,
@@ -960,7 +988,64 @@ def unset_channel_data(
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return self._delete(
-            f"/v1/objects/{collection}/{object_id}/channel_data/{channel_id}",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/channel_data/{channel_id}",
+                collection=collection,
+                object_id=object_id,
+                channel_id=channel_id,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                idempotency_key=idempotency_key,
+            ),
+            cast_to=NoneType,
+        )
+
+    def unset_preferences(
+        self,
+        collection: str,
+        object_id: str,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+        idempotency_key: str | None = None,
+    ) -> None:
+        """
+        Unsets the preference set for the object, removing it entirely.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+
+          idempotency_key: Specify a custom idempotency key for this request
+        """
+        if not collection:
+            raise ValueError(f"Expected a non-empty value for `collection` but received {collection!r}")
+        if not object_id:
+            raise ValueError(f"Expected a non-empty value for `object_id` but received {object_id!r}")
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            path_template(
+                "/v1/objects/{collection}/{object_id}/preferences/{id}",
+                collection=collection,
+                object_id=object_id,
+                id=id,
+            ),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -1041,7 +1126,7 @@ def list(
         if not collection:
             raise ValueError(f"Expected a non-empty value for `collection` but received {collection!r}")
         return self._get_api_list(
-            f"/v1/objects/{collection}",
+            path_template("/v1/objects/{collection}", collection=collection),
             page=AsyncEntriesCursor[Object],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1096,7 +1181,7 @@ async def delete(
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return await self._delete(
-            f"/v1/objects/{collection}/{id}",
+            path_template("/v1/objects/{collection}/{id}", collection=collection, id=id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -1150,7 +1235,9 @@ async def add_subscriptions(
         if not object_id:
             raise ValueError(f"Expected a non-empty value for `object_id` but received {object_id!r}")
         return await self._post(
-            f"/v1/objects/{collection}/{object_id}/subscriptions",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/subscriptions", collection=collection, object_id=object_id
+            ),
             body=await async_maybe_transform(
                 {
                     "recipients": recipients,
@@ -1206,7 +1293,9 @@ async def delete_subscriptions(
         if not object_id:
             raise ValueError(f"Expected a non-empty value for `object_id` but received {object_id!r}")
         return await self._delete(
-            f"/v1/objects/{collection}/{object_id}/subscriptions",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/subscriptions", collection=collection, object_id=object_id
+            ),
             body=await async_maybe_transform(
                 {"recipients": recipients}, object_delete_subscriptions_params.ObjectDeleteSubscriptionsParams
             ),
@@ -1251,7 +1340,7 @@ async def get(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._get(
-            f"/v1/objects/{collection}/{id}",
+            path_template("/v1/objects/{collection}/{id}", collection=collection, id=id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -1290,7 +1379,12 @@ async def get_channel_data(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return await self._get(
-            f"/v1/objects/{collection}/{object_id}/channel_data/{channel_id}",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/channel_data/{channel_id}",
+                collection=collection,
+                object_id=object_id,
+                channel_id=channel_id,
+            ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -1329,7 +1423,12 @@ async def get_preferences(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._get(
-            f"/v1/objects/{collection}/{object_id}/preferences/{id}",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/preferences/{id}",
+                collection=collection,
+                object_id=object_id,
+                id=id,
+            ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -1415,7 +1514,7 @@ def list_messages(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get_api_list(
-            f"/v1/objects/{collection}/{id}/messages",
+            path_template("/v1/objects/{collection}/{id}/messages", collection=collection, id=id),
             page=AsyncItemsCursor[Message],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1474,7 +1573,9 @@ async def list_preferences(
         if not object_id:
             raise ValueError(f"Expected a non-empty value for `object_id` but received {object_id!r}")
         return await self._get(
-            f"/v1/objects/{collection}/{object_id}/preferences",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/preferences", collection=collection, object_id=object_id
+            ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -1525,7 +1626,7 @@ def list_schedules(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get_api_list(
-            f"/v1/objects/{collection}/{id}/schedules",
+            path_template("/v1/objects/{collection}/{id}/schedules", collection=collection, id=id),
             page=AsyncEntriesCursor[Schedule],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1601,7 +1702,9 @@ def list_subscriptions(
         if not object_id:
             raise ValueError(f"Expected a non-empty value for `object_id` but received {object_id!r}")
         return self._get_api_list(
-            f"/v1/objects/{collection}/{object_id}/subscriptions",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/subscriptions", collection=collection, object_id=object_id
+            ),
             page=AsyncEntriesCursor[Subscription],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1679,7 +1782,7 @@ async def set(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._put(
-            f"/v1/objects/{collection}/{id}",
+            path_template("/v1/objects/{collection}/{id}", collection=collection, id=id),
             body=await async_maybe_transform(
                 {
                     "channel_data": channel_data,
@@ -1741,7 +1844,12 @@ async def set_channel_data(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return await self._put(
-            f"/v1/objects/{collection}/{object_id}/channel_data/{channel_id}",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/channel_data/{channel_id}",
+                collection=collection,
+                object_id=object_id,
+                channel_id=channel_id,
+            ),
             body=await async_maybe_transform({"data": data}, object_set_channel_data_params.ObjectSetChannelDataParams),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1818,7 +1926,12 @@ async def set_preferences(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._put(
-            f"/v1/objects/{collection}/{object_id}/preferences/{id}",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/preferences/{id}",
+                collection=collection,
+                object_id=object_id,
+                id=id,
+            ),
             body=await async_maybe_transform(
                 {
                     "_persistence_strategy": _persistence_strategy,
@@ -1876,7 +1989,64 @@ async def unset_channel_data(
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return await self._delete(
-            f"/v1/objects/{collection}/{object_id}/channel_data/{channel_id}",
+            path_template(
+                "/v1/objects/{collection}/{object_id}/channel_data/{channel_id}",
+                collection=collection,
+                object_id=object_id,
+                channel_id=channel_id,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                idempotency_key=idempotency_key,
+            ),
+            cast_to=NoneType,
+        )
+
+    async def unset_preferences(
+        self,
+        collection: str,
+        object_id: str,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+        idempotency_key: str | None = None,
+    ) -> None:
+        """
+        Unsets the preference set for the object, removing it entirely.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+
+          idempotency_key: Specify a custom idempotency key for this request
+        """
+        if not collection:
+            raise ValueError(f"Expected a non-empty value for `collection` but received {collection!r}")
+        if not object_id:
+            raise ValueError(f"Expected a non-empty value for `object_id` but received {object_id!r}")
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            path_template(
+                "/v1/objects/{collection}/{object_id}/preferences/{id}",
+                collection=collection,
+                object_id=object_id,
+                id=id,
+            ),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -1937,6 +2107,9 @@ def __init__(self, objects: ObjectsResource) -> None:
         self.unset_channel_data = to_raw_response_wrapper(
             objects.unset_channel_data,
         )
+        self.unset_preferences = to_raw_response_wrapper(
+            objects.unset_preferences,
+        )
 
     @cached_property
     def bulk(self) -> BulkResourceWithRawResponse:
@@ -1995,6 +2168,9 @@ def __init__(self, objects: AsyncObjectsResource) -> None:
         self.unset_channel_data = async_to_raw_response_wrapper(
             objects.unset_channel_data,
         )
+        self.unset_preferences = async_to_raw_response_wrapper(
+            objects.unset_preferences,
+        )
 
     @cached_property
     def bulk(self) -> AsyncBulkResourceWithRawResponse:
@@ -2053,6 +2229,9 @@ def __init__(self, objects: ObjectsResource) -> None:
         self.unset_channel_data = to_streamed_response_wrapper(
             objects.unset_channel_data,
         )
+        self.unset_preferences = to_streamed_response_wrapper(
+            objects.unset_preferences,
+        )
 
     @cached_property
     def bulk(self) -> BulkResourceWithStreamingResponse:
@@ -2111,6 +2290,9 @@ def __init__(self, objects: AsyncObjectsResource) -> None:
         self.unset_channel_data = async_to_streamed_response_wrapper(
             objects.unset_channel_data,
         )
+        self.unset_preferences = async_to_streamed_response_wrapper(
+            objects.unset_preferences,
+        )
 
     @cached_property
     def bulk(self) -> AsyncBulkResourceWithStreamingResponse:
diff --git a/src/knockapi/resources/providers/ms_teams.py b/src/knockapi/resources/providers/ms_teams.py
index c5fd020b..e36d8d56 100644
--- a/src/knockapi/resources/providers/ms_teams.py
+++ b/src/knockapi/resources/providers/ms_teams.py
@@ -5,7 +5,7 @@
 import httpx
 
 from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
-from ..._utils import maybe_transform, async_maybe_transform
+from ..._utils import path_template, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -84,7 +84,7 @@ def check_auth(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._get(
-            f"/v1/providers/ms-teams/{channel_id}/auth_check",
+            path_template("/v1/providers/ms-teams/{channel_id}/auth_check", channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -132,7 +132,7 @@ def list_channels(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._get(
-            f"/v1/providers/ms-teams/{channel_id}/channels",
+            path_template("/v1/providers/ms-teams/{channel_id}/channels", channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -182,7 +182,7 @@ def list_teams(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._get_api_list(
-            f"/v1/providers/ms-teams/{channel_id}/teams",
+            path_template("/v1/providers/ms-teams/{channel_id}/teams", channel_id=channel_id),
             page=SyncMsTeamsPagination[MsTeamListTeamsResponse],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -232,7 +232,7 @@ def revoke_access(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._put(
-            f"/v1/providers/ms-teams/{channel_id}/revoke_access",
+            path_template("/v1/providers/ms-teams/{channel_id}/revoke_access", channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -302,7 +302,7 @@ async def check_auth(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return await self._get(
-            f"/v1/providers/ms-teams/{channel_id}/auth_check",
+            path_template("/v1/providers/ms-teams/{channel_id}/auth_check", channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -350,7 +350,7 @@ async def list_channels(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return await self._get(
-            f"/v1/providers/ms-teams/{channel_id}/channels",
+            path_template("/v1/providers/ms-teams/{channel_id}/channels", channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -400,7 +400,7 @@ def list_teams(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._get_api_list(
-            f"/v1/providers/ms-teams/{channel_id}/teams",
+            path_template("/v1/providers/ms-teams/{channel_id}/teams", channel_id=channel_id),
             page=AsyncMsTeamsPagination[MsTeamListTeamsResponse],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -450,7 +450,7 @@ async def revoke_access(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return await self._put(
-            f"/v1/providers/ms-teams/{channel_id}/revoke_access",
+            path_template("/v1/providers/ms-teams/{channel_id}/revoke_access", channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
diff --git a/src/knockapi/resources/providers/slack.py b/src/knockapi/resources/providers/slack.py
index d9939596..b1340079 100644
--- a/src/knockapi/resources/providers/slack.py
+++ b/src/knockapi/resources/providers/slack.py
@@ -5,7 +5,7 @@
 import httpx
 
 from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
-from ..._utils import maybe_transform, async_maybe_transform
+from ..._utils import path_template, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -77,7 +77,7 @@ def check_auth(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._get(
-            f"/v1/providers/slack/{channel_id}/auth_check",
+            path_template("/v1/providers/slack/{channel_id}/auth_check", channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -120,7 +120,7 @@ def list_channels(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._get_api_list(
-            f"/v1/providers/slack/{channel_id}/channels",
+            path_template("/v1/providers/slack/{channel_id}/channels", channel_id=channel_id),
             page=SyncSlackChannelsCursor[SlackListChannelsResponse],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -170,7 +170,7 @@ def revoke_access(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._put(
-            f"/v1/providers/slack/{channel_id}/revoke_access",
+            path_template("/v1/providers/slack/{channel_id}/revoke_access", channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -238,7 +238,7 @@ async def check_auth(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return await self._get(
-            f"/v1/providers/slack/{channel_id}/auth_check",
+            path_template("/v1/providers/slack/{channel_id}/auth_check", channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -281,7 +281,7 @@ def list_channels(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._get_api_list(
-            f"/v1/providers/slack/{channel_id}/channels",
+            path_template("/v1/providers/slack/{channel_id}/channels", channel_id=channel_id),
             page=AsyncSlackChannelsCursor[SlackListChannelsResponse],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -331,7 +331,7 @@ async def revoke_access(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return await self._put(
-            f"/v1/providers/slack/{channel_id}/revoke_access",
+            path_template("/v1/providers/slack/{channel_id}/revoke_access", channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
diff --git a/src/knockapi/resources/tenants/tenants.py b/src/knockapi/resources/tenants/tenants.py
index 9fdee42f..d52fabf2 100644
--- a/src/knockapi/resources/tenants/tenants.py
+++ b/src/knockapi/resources/tenants/tenants.py
@@ -16,7 +16,7 @@
 )
 from ...types import tenant_get_params, tenant_set_params, tenant_list_params
 from ..._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given
-from ..._utils import maybe_transform, async_maybe_transform
+from ..._utils import path_template, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -154,7 +154,7 @@ def delete(
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return self._delete(
-            f"/v1/tenants/{id}",
+            path_template("/v1/tenants/{id}", id=id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -196,7 +196,7 @@ def get(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get(
-            f"/v1/tenants/{id}",
+            path_template("/v1/tenants/{id}", id=id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -255,7 +255,7 @@ def set(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._put(
-            f"/v1/tenants/{id}",
+            path_template("/v1/tenants/{id}", id=id),
             body=maybe_transform(
                 {
                     "channel_data": channel_data,
@@ -400,7 +400,7 @@ async def delete(
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return await self._delete(
-            f"/v1/tenants/{id}",
+            path_template("/v1/tenants/{id}", id=id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -442,7 +442,7 @@ async def get(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._get(
-            f"/v1/tenants/{id}",
+            path_template("/v1/tenants/{id}", id=id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -501,7 +501,7 @@ async def set(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._put(
-            f"/v1/tenants/{id}",
+            path_template("/v1/tenants/{id}", id=id),
             body=await async_maybe_transform(
                 {
                     "channel_data": channel_data,
diff --git a/src/knockapi/resources/users/feeds.py b/src/knockapi/resources/users/feeds.py
index 2ba95f7a..8f1836c2 100644
--- a/src/knockapi/resources/users/feeds.py
+++ b/src/knockapi/resources/users/feeds.py
@@ -7,7 +7,7 @@
 import httpx
 
 from ..._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
-from ..._utils import maybe_transform
+from ..._utils import path_template, maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -79,7 +79,7 @@ def get_settings(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get(
-            f"/v1/users/{user_id}/feeds/{id}/settings",
+            path_template("/v1/users/{user_id}/feeds/{id}/settings", user_id=user_id, id=id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -179,7 +179,7 @@ def list_items(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get_api_list(
-            f"/v1/users/{user_id}/feeds/{id}",
+            path_template("/v1/users/{user_id}/feeds/{id}", user_id=user_id, id=id),
             page=SyncEntriesCursor[FeedListItemsResponse],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -264,7 +264,7 @@ async def get_settings(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._get(
-            f"/v1/users/{user_id}/feeds/{id}/settings",
+            path_template("/v1/users/{user_id}/feeds/{id}/settings", user_id=user_id, id=id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -364,7 +364,7 @@ def list_items(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get_api_list(
-            f"/v1/users/{user_id}/feeds/{id}",
+            path_template("/v1/users/{user_id}/feeds/{id}", user_id=user_id, id=id),
             page=AsyncEntriesCursor[FeedListItemsResponse],
             options=make_request_options(
                 extra_headers=extra_headers,
diff --git a/src/knockapi/resources/users/guides.py b/src/knockapi/resources/users/guides.py
index c308b573..59477812 100644
--- a/src/knockapi/resources/users/guides.py
+++ b/src/knockapi/resources/users/guides.py
@@ -7,7 +7,7 @@
 import httpx
 
 from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
-from ..._utils import maybe_transform, async_maybe_transform
+from ..._utils import path_template, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -94,7 +94,7 @@ def get_channel(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._get(
-            f"/v1/users/{user_id}/guides/{channel_id}",
+            path_template("/v1/users/{user_id}/guides/{channel_id}", user_id=user_id, channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -172,7 +172,9 @@ def mark_message_as_archived(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._put(
-            f"/v1/users/{user_id}/guides/messages/{message_id}/archived",
+            path_template(
+                "/v1/users/{user_id}/guides/messages/{message_id}/archived", user_id=user_id, message_id=message_id
+            ),
             body=maybe_transform(
                 {
                     "channel_id": channel_id,
@@ -257,7 +259,9 @@ def mark_message_as_interacted(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._put(
-            f"/v1/users/{user_id}/guides/messages/{message_id}/interacted",
+            path_template(
+                "/v1/users/{user_id}/guides/messages/{message_id}/interacted", user_id=user_id, message_id=message_id
+            ),
             body=maybe_transform(
                 {
                     "channel_id": channel_id,
@@ -342,7 +346,9 @@ def mark_message_as_seen(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return self._put(
-            f"/v1/users/{user_id}/guides/messages/{message_id}/seen",
+            path_template(
+                "/v1/users/{user_id}/guides/messages/{message_id}/seen", user_id=user_id, message_id=message_id
+            ),
             body=maybe_transform(
                 {
                     "channel_id": channel_id,
@@ -431,7 +437,7 @@ async def get_channel(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return await self._get(
-            f"/v1/users/{user_id}/guides/{channel_id}",
+            path_template("/v1/users/{user_id}/guides/{channel_id}", user_id=user_id, channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -509,7 +515,9 @@ async def mark_message_as_archived(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return await self._put(
-            f"/v1/users/{user_id}/guides/messages/{message_id}/archived",
+            path_template(
+                "/v1/users/{user_id}/guides/messages/{message_id}/archived", user_id=user_id, message_id=message_id
+            ),
             body=await async_maybe_transform(
                 {
                     "channel_id": channel_id,
@@ -594,7 +602,9 @@ async def mark_message_as_interacted(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return await self._put(
-            f"/v1/users/{user_id}/guides/messages/{message_id}/interacted",
+            path_template(
+                "/v1/users/{user_id}/guides/messages/{message_id}/interacted", user_id=user_id, message_id=message_id
+            ),
             body=await async_maybe_transform(
                 {
                     "channel_id": channel_id,
@@ -679,7 +689,9 @@ async def mark_message_as_seen(
         if not message_id:
             raise ValueError(f"Expected a non-empty value for `message_id` but received {message_id!r}")
         return await self._put(
-            f"/v1/users/{user_id}/guides/messages/{message_id}/seen",
+            path_template(
+                "/v1/users/{user_id}/guides/messages/{message_id}/seen", user_id=user_id, message_id=message_id
+            ),
             body=await async_maybe_transform(
                 {
                     "channel_id": channel_id,
diff --git a/src/knockapi/resources/users/users.py b/src/knockapi/resources/users/users.py
index c60bbc2f..f6e1663b 100644
--- a/src/knockapi/resources/users/users.py
+++ b/src/knockapi/resources/users/users.py
@@ -44,7 +44,7 @@
     user_list_subscriptions_params,
 )
 from ..._types import Body, Omit, Query, Headers, NoneType, NotGiven, SequenceNotStr, omit, not_given
-from ..._utils import maybe_transform, async_maybe_transform
+from ..._utils import path_template, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
 from ..._response import (
@@ -183,7 +183,7 @@ def update(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return self._put(
-            f"/v1/users/{user_id}",
+            path_template("/v1/users/{user_id}", user_id=user_id),
             body=maybe_transform(
                 {
                     "avatar": avatar,
@@ -295,7 +295,7 @@ def delete(
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return self._delete(
-            f"/v1/users/{user_id}",
+            path_template("/v1/users/{user_id}", user_id=user_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -332,7 +332,7 @@ def get(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return self._get(
-            f"/v1/users/{user_id}",
+            path_template("/v1/users/{user_id}", user_id=user_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -368,7 +368,7 @@ def get_channel_data(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._get(
-            f"/v1/users/{user_id}/channel_data/{channel_id}",
+            path_template("/v1/users/{user_id}/channel_data/{channel_id}", user_id=user_id, channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -408,7 +408,7 @@ def get_preferences(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get(
-            f"/v1/users/{user_id}/preferences/{id}",
+            path_template("/v1/users/{user_id}/preferences/{id}", user_id=user_id, id=id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -496,7 +496,7 @@ def list_messages(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return self._get_api_list(
-            f"/v1/users/{user_id}/messages",
+            path_template("/v1/users/{user_id}/messages", user_id=user_id),
             page=SyncItemsCursor[Message],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -552,7 +552,7 @@ def list_preferences(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return self._get(
-            f"/v1/users/{user_id}/preferences",
+            path_template("/v1/users/{user_id}/preferences", user_id=user_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -600,7 +600,7 @@ def list_schedules(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return self._get_api_list(
-            f"/v1/users/{user_id}/schedules",
+            path_template("/v1/users/{user_id}/schedules", user_id=user_id),
             page=SyncEntriesCursor[Schedule],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -663,7 +663,7 @@ def list_subscriptions(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return self._get_api_list(
-            f"/v1/users/{user_id}/subscriptions",
+            path_template("/v1/users/{user_id}/subscriptions", user_id=user_id),
             page=SyncEntriesCursor[Subscription],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -717,7 +717,7 @@ def merge(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return self._post(
-            f"/v1/users/{user_id}/merge",
+            path_template("/v1/users/{user_id}/merge", user_id=user_id),
             body=maybe_transform({"from_user_id": from_user_id}, user_merge_params.UserMergeParams),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -767,7 +767,7 @@ def set_channel_data(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return self._put(
-            f"/v1/users/{user_id}/channel_data/{channel_id}",
+            path_template("/v1/users/{user_id}/channel_data/{channel_id}", user_id=user_id, channel_id=channel_id),
             body=maybe_transform({"data": data}, user_set_channel_data_params.UserSetChannelDataParams),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -837,7 +837,7 @@ def set_preferences(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._put(
-            f"/v1/users/{user_id}/preferences/{id}",
+            path_template("/v1/users/{user_id}/preferences/{id}", user_id=user_id, id=id),
             body=maybe_transform(
                 {
                     "_persistence_strategy": _persistence_strategy,
@@ -892,7 +892,51 @@ def unset_channel_data(
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return self._delete(
-            f"/v1/users/{user_id}/channel_data/{channel_id}",
+            path_template("/v1/users/{user_id}/channel_data/{channel_id}", user_id=user_id, channel_id=channel_id),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                idempotency_key=idempotency_key,
+            ),
+            cast_to=NoneType,
+        )
+
+    def unset_preferences(
+        self,
+        user_id: str,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+        idempotency_key: str | None = None,
+    ) -> None:
+        """
+        Unsets the preference set for the user, removing it entirely.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+
+          idempotency_key: Specify a custom idempotency key for this request
+        """
+        if not user_id:
+            raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            path_template("/v1/users/{user_id}/preferences/{id}", user_id=user_id, id=id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -1017,7 +1061,7 @@ async def update(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return await self._put(
-            f"/v1/users/{user_id}",
+            path_template("/v1/users/{user_id}", user_id=user_id),
             body=await async_maybe_transform(
                 {
                     "avatar": avatar,
@@ -1129,7 +1173,7 @@ async def delete(
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return await self._delete(
-            f"/v1/users/{user_id}",
+            path_template("/v1/users/{user_id}", user_id=user_id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -1166,7 +1210,7 @@ async def get(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return await self._get(
-            f"/v1/users/{user_id}",
+            path_template("/v1/users/{user_id}", user_id=user_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -1202,7 +1246,7 @@ async def get_channel_data(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return await self._get(
-            f"/v1/users/{user_id}/channel_data/{channel_id}",
+            path_template("/v1/users/{user_id}/channel_data/{channel_id}", user_id=user_id, channel_id=channel_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -1242,7 +1286,7 @@ async def get_preferences(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._get(
-            f"/v1/users/{user_id}/preferences/{id}",
+            path_template("/v1/users/{user_id}/preferences/{id}", user_id=user_id, id=id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -1332,7 +1376,7 @@ def list_messages(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return self._get_api_list(
-            f"/v1/users/{user_id}/messages",
+            path_template("/v1/users/{user_id}/messages", user_id=user_id),
             page=AsyncItemsCursor[Message],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1388,7 +1432,7 @@ async def list_preferences(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return await self._get(
-            f"/v1/users/{user_id}/preferences",
+            path_template("/v1/users/{user_id}/preferences", user_id=user_id),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -1436,7 +1480,7 @@ def list_schedules(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return self._get_api_list(
-            f"/v1/users/{user_id}/schedules",
+            path_template("/v1/users/{user_id}/schedules", user_id=user_id),
             page=AsyncEntriesCursor[Schedule],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1499,7 +1543,7 @@ def list_subscriptions(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return self._get_api_list(
-            f"/v1/users/{user_id}/subscriptions",
+            path_template("/v1/users/{user_id}/subscriptions", user_id=user_id),
             page=AsyncEntriesCursor[Subscription],
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1553,7 +1597,7 @@ async def merge(
         if not user_id:
             raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
         return await self._post(
-            f"/v1/users/{user_id}/merge",
+            path_template("/v1/users/{user_id}/merge", user_id=user_id),
             body=await async_maybe_transform({"from_user_id": from_user_id}, user_merge_params.UserMergeParams),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1603,7 +1647,7 @@ async def set_channel_data(
         if not channel_id:
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         return await self._put(
-            f"/v1/users/{user_id}/channel_data/{channel_id}",
+            path_template("/v1/users/{user_id}/channel_data/{channel_id}", user_id=user_id, channel_id=channel_id),
             body=await async_maybe_transform({"data": data}, user_set_channel_data_params.UserSetChannelDataParams),
             options=make_request_options(
                 extra_headers=extra_headers,
@@ -1673,7 +1717,7 @@ async def set_preferences(
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._put(
-            f"/v1/users/{user_id}/preferences/{id}",
+            path_template("/v1/users/{user_id}/preferences/{id}", user_id=user_id, id=id),
             body=await async_maybe_transform(
                 {
                     "_persistence_strategy": _persistence_strategy,
@@ -1728,7 +1772,51 @@ async def unset_channel_data(
             raise ValueError(f"Expected a non-empty value for `channel_id` but received {channel_id!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return await self._delete(
-            f"/v1/users/{user_id}/channel_data/{channel_id}",
+            path_template("/v1/users/{user_id}/channel_data/{channel_id}", user_id=user_id, channel_id=channel_id),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                idempotency_key=idempotency_key,
+            ),
+            cast_to=NoneType,
+        )
+
+    async def unset_preferences(
+        self,
+        user_id: str,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+        idempotency_key: str | None = None,
+    ) -> None:
+        """
+        Unsets the preference set for the user, removing it entirely.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+
+          idempotency_key: Specify a custom idempotency key for this request
+        """
+        if not user_id:
+            raise ValueError(f"Expected a non-empty value for `user_id` but received {user_id!r}")
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            path_template("/v1/users/{user_id}/preferences/{id}", user_id=user_id, id=id),
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -1786,6 +1874,9 @@ def __init__(self, users: UsersResource) -> None:
         self.unset_channel_data = to_raw_response_wrapper(
             users.unset_channel_data,
         )
+        self.unset_preferences = to_raw_response_wrapper(
+            users.unset_preferences,
+        )
 
     @cached_property
     def feeds(self) -> FeedsResourceWithRawResponse:
@@ -1857,6 +1948,9 @@ def __init__(self, users: AsyncUsersResource) -> None:
         self.unset_channel_data = async_to_raw_response_wrapper(
             users.unset_channel_data,
         )
+        self.unset_preferences = async_to_raw_response_wrapper(
+            users.unset_preferences,
+        )
 
     @cached_property
     def feeds(self) -> AsyncFeedsResourceWithRawResponse:
@@ -1928,6 +2022,9 @@ def __init__(self, users: UsersResource) -> None:
         self.unset_channel_data = to_streamed_response_wrapper(
             users.unset_channel_data,
         )
+        self.unset_preferences = to_streamed_response_wrapper(
+            users.unset_preferences,
+        )
 
     @cached_property
     def feeds(self) -> FeedsResourceWithStreamingResponse:
@@ -1999,6 +2096,9 @@ def __init__(self, users: AsyncUsersResource) -> None:
         self.unset_channel_data = async_to_streamed_response_wrapper(
             users.unset_channel_data,
         )
+        self.unset_preferences = async_to_streamed_response_wrapper(
+            users.unset_preferences,
+        )
 
     @cached_property
     def feeds(self) -> AsyncFeedsResourceWithStreamingResponse:
diff --git a/src/knockapi/resources/workflow_recipient_runs.py b/src/knockapi/resources/workflow_recipient_runs.py
new file mode 100644
index 00000000..8543a7b3
--- /dev/null
+++ b/src/knockapi/resources/workflow_recipient_runs.py
@@ -0,0 +1,352 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from datetime import datetime
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import workflow_recipient_run_list_params
+from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from .._utils import path_template, maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ..pagination import SyncItemsCursor, AsyncItemsCursor
+from .._base_client import AsyncPaginator, make_request_options
+from ..types.workflow_recipient_run import WorkflowRecipientRun
+from ..types.recipient_reference_param import RecipientReferenceParam
+from ..types.workflow_recipient_run_detail import WorkflowRecipientRunDetail
+
+__all__ = ["WorkflowRecipientRunsResource", "AsyncWorkflowRecipientRunsResource"]
+
+
+class WorkflowRecipientRunsResource(SyncAPIResource):
+    """
+    A workflow run represents an individual execution of a workflow for a specific recipient.
+    """
+
+    @cached_property
+    def with_raw_response(self) -> WorkflowRecipientRunsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/knocklabs/knock-python#accessing-raw-response-data-eg-headers
+        """
+        return WorkflowRecipientRunsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> WorkflowRecipientRunsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/knocklabs/knock-python#with_streaming_response
+        """
+        return WorkflowRecipientRunsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        ending_at: Union[str, datetime] | Omit = omit,
+        has_errors: bool | Omit = omit,
+        page_size: int | Omit = omit,
+        recipient: RecipientReferenceParam | Omit = omit,
+        starting_at: Union[str, datetime] | Omit = omit,
+        status: List[Literal["queued", "processing", "paused", "completed", "cancelled"]] | Omit = omit,
+        tenant: str | Omit = omit,
+        workflow: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SyncItemsCursor[WorkflowRecipientRun]:
+        """
+        Returns a paginated list of workflow recipient runs for the current environment.
+
+        Args:
+          after: The cursor to fetch entries after.
+
+          before: The cursor to fetch entries before.
+
+          ending_at: Limits the results to workflow recipient runs started before the given date.
+
+          has_errors: Limits the results to workflow recipient runs that have errors.
+
+          page_size: The number of items per page (defaults to 50).
+
+          recipient: Limits the results to workflow recipient runs for the given recipient. Accepts a
+              user ID string or an object reference with `id` and `collection`.
+
+          starting_at: Limits the results to workflow recipient runs started after the given date.
+
+          status: Limits the results to workflow recipient runs with the given status.
+
+          tenant: Limits the results to workflow recipient runs for the given tenant.
+
+          workflow: Limits the results to workflow recipient runs for the given workflow key.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get_api_list(
+            "/v1/workflow_recipient_runs",
+            page=SyncItemsCursor[WorkflowRecipientRun],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "before": before,
+                        "ending_at": ending_at,
+                        "has_errors": has_errors,
+                        "page_size": page_size,
+                        "recipient": recipient,
+                        "starting_at": starting_at,
+                        "status": status,
+                        "tenant": tenant,
+                        "workflow": workflow,
+                    },
+                    workflow_recipient_run_list_params.WorkflowRecipientRunListParams,
+                ),
+            ),
+            model=WorkflowRecipientRun,
+        )
+
+    def get(
+        self,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> WorkflowRecipientRunDetail:
+        """
+        Returns a single workflow recipient run with its associated events.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return self._get(
+            path_template("/v1/workflow_recipient_runs/{id}", id=id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=WorkflowRecipientRunDetail,
+        )
+
+
+class AsyncWorkflowRecipientRunsResource(AsyncAPIResource):
+    """
+    A workflow run represents an individual execution of a workflow for a specific recipient.
+    """
+
+    @cached_property
+    def with_raw_response(self) -> AsyncWorkflowRecipientRunsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/knocklabs/knock-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncWorkflowRecipientRunsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncWorkflowRecipientRunsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/knocklabs/knock-python#with_streaming_response
+        """
+        return AsyncWorkflowRecipientRunsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        after: str | Omit = omit,
+        before: str | Omit = omit,
+        ending_at: Union[str, datetime] | Omit = omit,
+        has_errors: bool | Omit = omit,
+        page_size: int | Omit = omit,
+        recipient: RecipientReferenceParam | Omit = omit,
+        starting_at: Union[str, datetime] | Omit = omit,
+        status: List[Literal["queued", "processing", "paused", "completed", "cancelled"]] | Omit = omit,
+        tenant: str | Omit = omit,
+        workflow: str | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncPaginator[WorkflowRecipientRun, AsyncItemsCursor[WorkflowRecipientRun]]:
+        """
+        Returns a paginated list of workflow recipient runs for the current environment.
+
+        Args:
+          after: The cursor to fetch entries after.
+
+          before: The cursor to fetch entries before.
+
+          ending_at: Limits the results to workflow recipient runs started before the given date.
+
+          has_errors: Limits the results to workflow recipient runs that have errors.
+
+          page_size: The number of items per page (defaults to 50).
+
+          recipient: Limits the results to workflow recipient runs for the given recipient. Accepts a
+              user ID string or an object reference with `id` and `collection`.
+
+          starting_at: Limits the results to workflow recipient runs started after the given date.
+
+          status: Limits the results to workflow recipient runs with the given status.
+
+          tenant: Limits the results to workflow recipient runs for the given tenant.
+
+          workflow: Limits the results to workflow recipient runs for the given workflow key.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get_api_list(
+            "/v1/workflow_recipient_runs",
+            page=AsyncItemsCursor[WorkflowRecipientRun],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "after": after,
+                        "before": before,
+                        "ending_at": ending_at,
+                        "has_errors": has_errors,
+                        "page_size": page_size,
+                        "recipient": recipient,
+                        "starting_at": starting_at,
+                        "status": status,
+                        "tenant": tenant,
+                        "workflow": workflow,
+                    },
+                    workflow_recipient_run_list_params.WorkflowRecipientRunListParams,
+                ),
+            ),
+            model=WorkflowRecipientRun,
+        )
+
+    async def get(
+        self,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> WorkflowRecipientRunDetail:
+        """
+        Returns a single workflow recipient run with its associated events.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return await self._get(
+            path_template("/v1/workflow_recipient_runs/{id}", id=id),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=WorkflowRecipientRunDetail,
+        )
+
+
+class WorkflowRecipientRunsResourceWithRawResponse:
+    def __init__(self, workflow_recipient_runs: WorkflowRecipientRunsResource) -> None:
+        self._workflow_recipient_runs = workflow_recipient_runs
+
+        self.list = to_raw_response_wrapper(
+            workflow_recipient_runs.list,
+        )
+        self.get = to_raw_response_wrapper(
+            workflow_recipient_runs.get,
+        )
+
+
+class AsyncWorkflowRecipientRunsResourceWithRawResponse:
+    def __init__(self, workflow_recipient_runs: AsyncWorkflowRecipientRunsResource) -> None:
+        self._workflow_recipient_runs = workflow_recipient_runs
+
+        self.list = async_to_raw_response_wrapper(
+            workflow_recipient_runs.list,
+        )
+        self.get = async_to_raw_response_wrapper(
+            workflow_recipient_runs.get,
+        )
+
+
+class WorkflowRecipientRunsResourceWithStreamingResponse:
+    def __init__(self, workflow_recipient_runs: WorkflowRecipientRunsResource) -> None:
+        self._workflow_recipient_runs = workflow_recipient_runs
+
+        self.list = to_streamed_response_wrapper(
+            workflow_recipient_runs.list,
+        )
+        self.get = to_streamed_response_wrapper(
+            workflow_recipient_runs.get,
+        )
+
+
+class AsyncWorkflowRecipientRunsResourceWithStreamingResponse:
+    def __init__(self, workflow_recipient_runs: AsyncWorkflowRecipientRunsResource) -> None:
+        self._workflow_recipient_runs = workflow_recipient_runs
+
+        self.list = async_to_streamed_response_wrapper(
+            workflow_recipient_runs.list,
+        )
+        self.get = async_to_streamed_response_wrapper(
+            workflow_recipient_runs.get,
+        )
diff --git a/src/knockapi/resources/workflows.py b/src/knockapi/resources/workflows.py
index d6012ebd..6080eb85 100644
--- a/src/knockapi/resources/workflows.py
+++ b/src/knockapi/resources/workflows.py
@@ -8,7 +8,7 @@
 
 from ..types import workflow_cancel_params, workflow_trigger_params
 from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, SequenceNotStr, omit, not_given
-from .._utils import maybe_transform, async_maybe_transform
+from .._utils import path_template, maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -93,7 +93,7 @@ def cancel(
             raise ValueError(f"Expected a non-empty value for `key` but received {key!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return self._post(
-            f"/v1/workflows/{key}/cancel",
+            path_template("/v1/workflows/{key}/cancel", key=key),
             body=maybe_transform(
                 {
                     "cancellation_key": cancellation_key,
@@ -169,7 +169,7 @@ def trigger(
         if not key:
             raise ValueError(f"Expected a non-empty value for `key` but received {key!r}")
         return self._post(
-            f"/v1/workflows/{key}/trigger",
+            path_template("/v1/workflows/{key}/trigger", key=key),
             body=maybe_transform(
                 {
                     "recipients": recipients,
@@ -258,7 +258,7 @@ async def cancel(
             raise ValueError(f"Expected a non-empty value for `key` but received {key!r}")
         extra_headers = {"Accept": "*/*", **(extra_headers or {})}
         return await self._post(
-            f"/v1/workflows/{key}/cancel",
+            path_template("/v1/workflows/{key}/cancel", key=key),
             body=await async_maybe_transform(
                 {
                     "cancellation_key": cancellation_key,
@@ -334,7 +334,7 @@ async def trigger(
         if not key:
             raise ValueError(f"Expected a non-empty value for `key` but received {key!r}")
         return await self._post(
-            f"/v1/workflows/{key}/trigger",
+            path_template("/v1/workflows/{key}/trigger", key=key),
             body=await async_maybe_transform(
                 {
                     "recipients": recipients,
diff --git a/src/knockapi/types/__init__.py b/src/knockapi/types/__init__.py
index c0b735db..7d0a2293 100644
--- a/src/knockapi/types/__init__.py
+++ b/src/knockapi/types/__init__.py
@@ -31,6 +31,7 @@
 from .schedule_delete_params import ScheduleDeleteParams as ScheduleDeleteParams
 from .schedule_update_params import ScheduleUpdateParams as ScheduleUpdateParams
 from .workflow_cancel_params import WorkflowCancelParams as WorkflowCancelParams
+from .workflow_recipient_run import WorkflowRecipientRun as WorkflowRecipientRun
 from .recipient_request_param import RecipientRequestParam as RecipientRequestParam
 from .workflow_trigger_params import WorkflowTriggerParams as WorkflowTriggerParams
 from .schedule_create_response import ScheduleCreateResponse as ScheduleCreateResponse
@@ -51,7 +52,9 @@
 from .message_get_content_response import MessageGetContentResponse as MessageGetContentResponse
 from .object_list_schedules_params import ObjectListSchedulesParams as ObjectListSchedulesParams
 from .user_set_channel_data_params import UserSetChannelDataParams as UserSetChannelDataParams
+from .workflow_recipient_run_event import WorkflowRecipientRunEvent as WorkflowRecipientRunEvent
 from .object_set_preferences_params import ObjectSetPreferencesParams as ObjectSetPreferencesParams
+from .workflow_recipient_run_detail import WorkflowRecipientRunDetail as WorkflowRecipientRunDetail
 from .audience_list_members_response import AudienceListMembersResponse as AudienceListMembersResponse
 from .audience_remove_members_params import AudienceRemoveMembersParams as AudienceRemoveMembersParams
 from .message_list_activities_params import MessageListActivitiesParams as MessageListActivitiesParams
@@ -66,4 +69,5 @@
 from .object_add_subscriptions_response import ObjectAddSubscriptionsResponse as ObjectAddSubscriptionsResponse
 from .inline_identify_user_request_param import InlineIdentifyUserRequestParam as InlineIdentifyUserRequestParam
 from .object_delete_subscriptions_params import ObjectDeleteSubscriptionsParams as ObjectDeleteSubscriptionsParams
+from .workflow_recipient_run_list_params import WorkflowRecipientRunListParams as WorkflowRecipientRunListParams
 from .object_delete_subscriptions_response import ObjectDeleteSubscriptionsResponse as ObjectDeleteSubscriptionsResponse
diff --git a/src/knockapi/types/message_event.py b/src/knockapi/types/message_event.py
index 0bf16aa2..fe1a72c1 100644
--- a/src/knockapi/types/message_event.py
+++ b/src/knockapi/types/message_event.py
@@ -36,6 +36,7 @@ class MessageEvent(BaseModel):
     type: Literal[
         "message.archived",
         "message.bounced",
+        "message.created",
         "message.delivered",
         "message.delivery_attempted",
         "message.interacted",
diff --git a/src/knockapi/types/users/guide_get_channel_response.py b/src/knockapi/types/users/guide_get_channel_response.py
index ef9efb13..a9277e4e 100644
--- a/src/knockapi/types/users/guide_get_channel_response.py
+++ b/src/knockapi/types/users/guide_get_channel_response.py
@@ -99,6 +99,9 @@ class Entry(BaseModel):
 
     channel_id: Optional[str] = None
 
+    dashboard_url: Optional[str] = None
+    """URL to this guide in the Knock dashboard"""
+
     inserted_at: Optional[datetime] = None
 
     key: Optional[str] = None
diff --git a/src/knockapi/types/workflow_recipient_run.py b/src/knockapi/types/workflow_recipient_run.py
new file mode 100644
index 00000000..884b6846
--- /dev/null
+++ b/src/knockapi/types/workflow_recipient_run.py
@@ -0,0 +1,84 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .recipient import Recipient
+from .recipient_reference import RecipientReference
+
+__all__ = ["WorkflowRecipientRun", "TriggerSource"]
+
+
+class TriggerSource(BaseModel):
+    """Describes how the workflow was triggered."""
+
+    type: Literal["api", "audience", "schedule", "broadcast", "workflow_step", "integration", "rehearsal"]
+    """The type of trigger source.
+
+    One of `api`, `audience`, `schedule`, `broadcast`, `workflow_step`,
+    `integration`, or `rehearsal`.
+    """
+
+    audience_key: Optional[str] = None
+    """The key of the audience that triggered the workflow."""
+
+    cancellation_key: Optional[str] = None
+    """The cancellation key provided when the workflow was triggered via the API."""
+
+    schedule_id: Optional[str] = None
+    """The ID of the schedule that triggered the workflow."""
+
+
+class WorkflowRecipientRun(BaseModel):
+    """
+    A workflow recipient run represents an individual execution of a workflow for a specific recipient.
+    """
+
+    id: str
+    """The unique identifier for the workflow recipient run (per-recipient)."""
+
+    api_typename: str = FieldInfo(alias="__typename")
+    """The typename of the schema."""
+
+    inserted_at: datetime
+    """Timestamp when the resource was created."""
+
+    recipient: RecipientReference
+    """
+    A reference to a recipient, either a user identifier (string) or an object
+    reference (ID, collection).
+    """
+
+    status: Literal["queued", "processing", "paused", "completed", "cancelled"]
+    """The current status of the workflow recipient run.
+
+    One of `queued`, `processing`, `paused`, `completed`, or `cancelled`.
+    """
+
+    trigger_source: TriggerSource
+    """Describes how the workflow was triggered."""
+
+    updated_at: datetime
+    """The timestamp when the resource was last updated."""
+
+    workflow: str
+    """The key of the workflow that was executed."""
+
+    workflow_run_id: str
+    """
+    The identifier for the top-level workflow run shared across all recipients in a
+    single trigger.
+    """
+
+    actor: Optional[Recipient] = None
+    """A recipient of a notification, which is either a user or an object."""
+
+    error_count: Optional[int] = None
+    """The number of errors encountered during the workflow recipient run."""
+
+    tenant: Optional[str] = None
+    """The tenant associated with the workflow recipient run."""
diff --git a/src/knockapi/types/workflow_recipient_run_detail.py b/src/knockapi/types/workflow_recipient_run_detail.py
new file mode 100644
index 00000000..a35319ef
--- /dev/null
+++ b/src/knockapi/types/workflow_recipient_run_detail.py
@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from .workflow_recipient_run import WorkflowRecipientRun
+from .workflow_recipient_run_event import WorkflowRecipientRunEvent
+
+__all__ = ["WorkflowRecipientRunDetail"]
+
+
+class WorkflowRecipientRunDetail(WorkflowRecipientRun):
+    """A single workflow recipient run with its events."""
+
+    events: List[WorkflowRecipientRunEvent]
+    """A list of events that occurred during the workflow recipient run."""
diff --git a/src/knockapi/types/workflow_recipient_run_event.py b/src/knockapi/types/workflow_recipient_run_event.py
new file mode 100644
index 00000000..56694b6f
--- /dev/null
+++ b/src/knockapi/types/workflow_recipient_run_event.py
@@ -0,0 +1,45 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["WorkflowRecipientRunEvent"]
+
+
+class WorkflowRecipientRunEvent(BaseModel):
+    """An event that occurred during a workflow recipient run."""
+
+    id: str
+    """The unique identifier for the event."""
+
+    api_typename: str = FieldInfo(alias="__typename")
+    """The typename of the schema."""
+
+    event: str
+    """The type of event that occurred."""
+
+    inserted_at: datetime
+    """Timestamp when the resource was created."""
+
+    status: Literal["ok", "error"]
+    """Whether the event represents a successful or error state."""
+
+    attempt: Optional[int] = None
+    """The attempt number of the workflow recipient run event.
+
+    Increments for each retry.
+    """
+
+    data: Optional[Dict[str, object]] = None
+    """Event-specific data associated with the event."""
+
+    step_ref: Optional[str] = None
+    """The reference of the workflow step associated with this event."""
+
+    step_type: Optional[str] = None
+    """The type of workflow step associated with this event."""
diff --git a/src/knockapi/types/workflow_recipient_run_list_params.py b/src/knockapi/types/workflow_recipient_run_list_params.py
new file mode 100644
index 00000000..4b0a3bc8
--- /dev/null
+++ b/src/knockapi/types/workflow_recipient_run_list_params.py
@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from datetime import datetime
+from typing_extensions import Literal, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+from .recipient_reference_param import RecipientReferenceParam
+
+__all__ = ["WorkflowRecipientRunListParams"]
+
+
+class WorkflowRecipientRunListParams(TypedDict, total=False):
+    after: str
+    """The cursor to fetch entries after."""
+
+    before: str
+    """The cursor to fetch entries before."""
+
+    ending_at: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]
+    """Limits the results to workflow recipient runs started before the given date."""
+
+    has_errors: bool
+    """Limits the results to workflow recipient runs that have errors."""
+
+    page_size: int
+    """The number of items per page (defaults to 50)."""
+
+    recipient: RecipientReferenceParam
+    """Limits the results to workflow recipient runs for the given recipient.
+
+    Accepts a user ID string or an object reference with `id` and `collection`.
+    """
+
+    starting_at: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]
+    """Limits the results to workflow recipient runs started after the given date."""
+
+    status: List[Literal["queued", "processing", "paused", "completed", "cancelled"]]
+    """Limits the results to workflow recipient runs with the given status."""
+
+    tenant: str
+    """Limits the results to workflow recipient runs for the given tenant."""
+
+    workflow: str
+    """Limits the results to workflow recipient runs for the given workflow key."""
diff --git a/tests/api_resources/channels/test_bulk.py b/tests/api_resources/channels/test_bulk.py
index 189a5b57..1c5c4f51 100644
--- a/tests/api_resources/channels/test_bulk.py
+++ b/tests/api_resources/channels/test_bulk.py
@@ -18,7 +18,6 @@
 class TestBulk:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_update_message_status(self, client: Knock) -> None:
         bulk = client.channels.bulk.update_message_status(
@@ -27,7 +26,6 @@ def test_method_update_message_status(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_update_message_status_with_all_params(self, client: Knock) -> None:
         bulk = client.channels.bulk.update_message_status(
@@ -46,7 +44,6 @@ def test_method_update_message_status_with_all_params(self, client: Knock) -> No
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_update_message_status(self, client: Knock) -> None:
         response = client.channels.bulk.with_raw_response.update_message_status(
@@ -59,7 +56,6 @@ def test_raw_response_update_message_status(self, client: Knock) -> None:
         bulk = response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_update_message_status(self, client: Knock) -> None:
         with client.channels.bulk.with_streaming_response.update_message_status(
@@ -74,7 +70,6 @@ def test_streaming_response_update_message_status(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_update_message_status(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -89,7 +84,6 @@ class TestAsyncBulk:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_update_message_status(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.channels.bulk.update_message_status(
@@ -98,7 +92,6 @@ async def test_method_update_message_status(self, async_client: AsyncKnock) -> N
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_update_message_status_with_all_params(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.channels.bulk.update_message_status(
@@ -117,7 +110,6 @@ async def test_method_update_message_status_with_all_params(self, async_client:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_update_message_status(self, async_client: AsyncKnock) -> None:
         response = await async_client.channels.bulk.with_raw_response.update_message_status(
@@ -130,7 +122,6 @@ async def test_raw_response_update_message_status(self, async_client: AsyncKnock
         bulk = await response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_update_message_status(self, async_client: AsyncKnock) -> None:
         async with async_client.channels.bulk.with_streaming_response.update_message_status(
@@ -145,7 +136,6 @@ async def test_streaming_response_update_message_status(self, async_client: Asyn
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_update_message_status(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
diff --git a/tests/api_resources/integrations/test_census.py b/tests/api_resources/integrations/test_census.py
index aaa71a34..71490805 100644
--- a/tests/api_resources/integrations/test_census.py
+++ b/tests/api_resources/integrations/test_census.py
@@ -17,7 +17,6 @@
 class TestCensus:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_custom_destination(self, client: Knock) -> None:
         census = client.integrations.census.custom_destination(
@@ -27,7 +26,6 @@ def test_method_custom_destination(self, client: Knock) -> None:
         )
         assert_matches_type(CensusCustomDestinationResponse, census, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_custom_destination_with_all_params(self, client: Knock) -> None:
         census = client.integrations.census.custom_destination(
@@ -38,7 +36,6 @@ def test_method_custom_destination_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(CensusCustomDestinationResponse, census, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_custom_destination(self, client: Knock) -> None:
         response = client.integrations.census.with_raw_response.custom_destination(
@@ -52,7 +49,6 @@ def test_raw_response_custom_destination(self, client: Knock) -> None:
         census = response.parse()
         assert_matches_type(CensusCustomDestinationResponse, census, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_custom_destination(self, client: Knock) -> None:
         with client.integrations.census.with_streaming_response.custom_destination(
@@ -74,7 +70,6 @@ class TestAsyncCensus:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_custom_destination(self, async_client: AsyncKnock) -> None:
         census = await async_client.integrations.census.custom_destination(
@@ -84,7 +79,6 @@ async def test_method_custom_destination(self, async_client: AsyncKnock) -> None
         )
         assert_matches_type(CensusCustomDestinationResponse, census, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_custom_destination_with_all_params(self, async_client: AsyncKnock) -> None:
         census = await async_client.integrations.census.custom_destination(
@@ -95,7 +89,6 @@ async def test_method_custom_destination_with_all_params(self, async_client: Asy
         )
         assert_matches_type(CensusCustomDestinationResponse, census, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_custom_destination(self, async_client: AsyncKnock) -> None:
         response = await async_client.integrations.census.with_raw_response.custom_destination(
@@ -109,7 +102,6 @@ async def test_raw_response_custom_destination(self, async_client: AsyncKnock) -
         census = await response.parse()
         assert_matches_type(CensusCustomDestinationResponse, census, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_custom_destination(self, async_client: AsyncKnock) -> None:
         async with async_client.integrations.census.with_streaming_response.custom_destination(
diff --git a/tests/api_resources/integrations/test_hightouch.py b/tests/api_resources/integrations/test_hightouch.py
index 98943421..14b4f67f 100644
--- a/tests/api_resources/integrations/test_hightouch.py
+++ b/tests/api_resources/integrations/test_hightouch.py
@@ -17,7 +17,6 @@
 class TestHightouch:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_embedded_destination(self, client: Knock) -> None:
         hightouch = client.integrations.hightouch.embedded_destination(
@@ -27,7 +26,6 @@ def test_method_embedded_destination(self, client: Knock) -> None:
         )
         assert_matches_type(HightouchEmbeddedDestinationResponse, hightouch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_embedded_destination_with_all_params(self, client: Knock) -> None:
         hightouch = client.integrations.hightouch.embedded_destination(
@@ -38,7 +36,6 @@ def test_method_embedded_destination_with_all_params(self, client: Knock) -> Non
         )
         assert_matches_type(HightouchEmbeddedDestinationResponse, hightouch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_embedded_destination(self, client: Knock) -> None:
         response = client.integrations.hightouch.with_raw_response.embedded_destination(
@@ -52,7 +49,6 @@ def test_raw_response_embedded_destination(self, client: Knock) -> None:
         hightouch = response.parse()
         assert_matches_type(HightouchEmbeddedDestinationResponse, hightouch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_embedded_destination(self, client: Knock) -> None:
         with client.integrations.hightouch.with_streaming_response.embedded_destination(
@@ -74,7 +70,6 @@ class TestAsyncHightouch:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_embedded_destination(self, async_client: AsyncKnock) -> None:
         hightouch = await async_client.integrations.hightouch.embedded_destination(
@@ -84,7 +79,6 @@ async def test_method_embedded_destination(self, async_client: AsyncKnock) -> No
         )
         assert_matches_type(HightouchEmbeddedDestinationResponse, hightouch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_embedded_destination_with_all_params(self, async_client: AsyncKnock) -> None:
         hightouch = await async_client.integrations.hightouch.embedded_destination(
@@ -95,7 +89,6 @@ async def test_method_embedded_destination_with_all_params(self, async_client: A
         )
         assert_matches_type(HightouchEmbeddedDestinationResponse, hightouch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_embedded_destination(self, async_client: AsyncKnock) -> None:
         response = await async_client.integrations.hightouch.with_raw_response.embedded_destination(
@@ -109,7 +102,6 @@ async def test_raw_response_embedded_destination(self, async_client: AsyncKnock)
         hightouch = await response.parse()
         assert_matches_type(HightouchEmbeddedDestinationResponse, hightouch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_embedded_destination(self, async_client: AsyncKnock) -> None:
         async with async_client.integrations.hightouch.with_streaming_response.embedded_destination(
diff --git a/tests/api_resources/messages/test_batch.py b/tests/api_resources/messages/test_batch.py
index 1e3ee077..640a2037 100644
--- a/tests/api_resources/messages/test_batch.py
+++ b/tests/api_resources/messages/test_batch.py
@@ -26,7 +26,6 @@
 class TestBatch:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_archive(self, client: Knock) -> None:
         batch = client.messages.batch.archive(
@@ -34,7 +33,6 @@ def test_method_archive(self, client: Knock) -> None:
         )
         assert_matches_type(BatchArchiveResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_archive(self, client: Knock) -> None:
         response = client.messages.batch.with_raw_response.archive(
@@ -46,7 +44,6 @@ def test_raw_response_archive(self, client: Knock) -> None:
         batch = response.parse()
         assert_matches_type(BatchArchiveResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_archive(self, client: Knock) -> None:
         with client.messages.batch.with_streaming_response.archive(
@@ -60,7 +57,7 @@ def test_streaming_response_archive(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
+    @pytest.mark.skip(reason="Steady does not support bracket-style array query params")
     @parametrize
     def test_method_get_content(self, client: Knock) -> None:
         batch = client.messages.batch.get_content(
@@ -68,7 +65,7 @@ def test_method_get_content(self, client: Knock) -> None:
         )
         assert_matches_type(BatchGetContentResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
+    @pytest.mark.skip(reason="Steady does not support bracket-style array query params")
     @parametrize
     def test_raw_response_get_content(self, client: Knock) -> None:
         response = client.messages.batch.with_raw_response.get_content(
@@ -80,7 +77,7 @@ def test_raw_response_get_content(self, client: Knock) -> None:
         batch = response.parse()
         assert_matches_type(BatchGetContentResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
+    @pytest.mark.skip(reason="Steady does not support bracket-style array query params")
     @parametrize
     def test_streaming_response_get_content(self, client: Knock) -> None:
         with client.messages.batch.with_streaming_response.get_content(
@@ -94,7 +91,6 @@ def test_streaming_response_get_content(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_as_interacted(self, client: Knock) -> None:
         batch = client.messages.batch.mark_as_interacted(
@@ -102,7 +98,6 @@ def test_method_mark_as_interacted(self, client: Knock) -> None:
         )
         assert_matches_type(BatchMarkAsInteractedResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_as_interacted_with_all_params(self, client: Knock) -> None:
         batch = client.messages.batch.mark_as_interacted(
@@ -111,7 +106,6 @@ def test_method_mark_as_interacted_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(BatchMarkAsInteractedResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_as_interacted(self, client: Knock) -> None:
         response = client.messages.batch.with_raw_response.mark_as_interacted(
@@ -123,7 +117,6 @@ def test_raw_response_mark_as_interacted(self, client: Knock) -> None:
         batch = response.parse()
         assert_matches_type(BatchMarkAsInteractedResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_as_interacted(self, client: Knock) -> None:
         with client.messages.batch.with_streaming_response.mark_as_interacted(
@@ -137,7 +130,6 @@ def test_streaming_response_mark_as_interacted(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_as_read(self, client: Knock) -> None:
         batch = client.messages.batch.mark_as_read(
@@ -145,7 +137,6 @@ def test_method_mark_as_read(self, client: Knock) -> None:
         )
         assert_matches_type(BatchMarkAsReadResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_as_read(self, client: Knock) -> None:
         response = client.messages.batch.with_raw_response.mark_as_read(
@@ -157,7 +148,6 @@ def test_raw_response_mark_as_read(self, client: Knock) -> None:
         batch = response.parse()
         assert_matches_type(BatchMarkAsReadResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_as_read(self, client: Knock) -> None:
         with client.messages.batch.with_streaming_response.mark_as_read(
@@ -171,7 +161,6 @@ def test_streaming_response_mark_as_read(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_as_seen(self, client: Knock) -> None:
         batch = client.messages.batch.mark_as_seen(
@@ -179,7 +168,6 @@ def test_method_mark_as_seen(self, client: Knock) -> None:
         )
         assert_matches_type(BatchMarkAsSeenResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_as_seen(self, client: Knock) -> None:
         response = client.messages.batch.with_raw_response.mark_as_seen(
@@ -191,7 +179,6 @@ def test_raw_response_mark_as_seen(self, client: Knock) -> None:
         batch = response.parse()
         assert_matches_type(BatchMarkAsSeenResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_as_seen(self, client: Knock) -> None:
         with client.messages.batch.with_streaming_response.mark_as_seen(
@@ -205,7 +192,6 @@ def test_streaming_response_mark_as_seen(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_as_unread(self, client: Knock) -> None:
         batch = client.messages.batch.mark_as_unread(
@@ -213,7 +199,6 @@ def test_method_mark_as_unread(self, client: Knock) -> None:
         )
         assert_matches_type(BatchMarkAsUnreadResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_as_unread(self, client: Knock) -> None:
         response = client.messages.batch.with_raw_response.mark_as_unread(
@@ -225,7 +210,6 @@ def test_raw_response_mark_as_unread(self, client: Knock) -> None:
         batch = response.parse()
         assert_matches_type(BatchMarkAsUnreadResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_as_unread(self, client: Knock) -> None:
         with client.messages.batch.with_streaming_response.mark_as_unread(
@@ -239,7 +223,6 @@ def test_streaming_response_mark_as_unread(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_as_unseen(self, client: Knock) -> None:
         batch = client.messages.batch.mark_as_unseen(
@@ -247,7 +230,6 @@ def test_method_mark_as_unseen(self, client: Knock) -> None:
         )
         assert_matches_type(BatchMarkAsUnseenResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_as_unseen(self, client: Knock) -> None:
         response = client.messages.batch.with_raw_response.mark_as_unseen(
@@ -259,7 +241,6 @@ def test_raw_response_mark_as_unseen(self, client: Knock) -> None:
         batch = response.parse()
         assert_matches_type(BatchMarkAsUnseenResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_as_unseen(self, client: Knock) -> None:
         with client.messages.batch.with_streaming_response.mark_as_unseen(
@@ -273,7 +254,6 @@ def test_streaming_response_mark_as_unseen(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_unarchive(self, client: Knock) -> None:
         batch = client.messages.batch.unarchive(
@@ -281,7 +261,6 @@ def test_method_unarchive(self, client: Knock) -> None:
         )
         assert_matches_type(BatchUnarchiveResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_unarchive(self, client: Knock) -> None:
         response = client.messages.batch.with_raw_response.unarchive(
@@ -293,7 +272,6 @@ def test_raw_response_unarchive(self, client: Knock) -> None:
         batch = response.parse()
         assert_matches_type(BatchUnarchiveResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_unarchive(self, client: Knock) -> None:
         with client.messages.batch.with_streaming_response.unarchive(
@@ -313,7 +291,6 @@ class TestAsyncBatch:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_archive(self, async_client: AsyncKnock) -> None:
         batch = await async_client.messages.batch.archive(
@@ -321,7 +298,6 @@ async def test_method_archive(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BatchArchiveResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_archive(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.batch.with_raw_response.archive(
@@ -333,7 +309,6 @@ async def test_raw_response_archive(self, async_client: AsyncKnock) -> None:
         batch = await response.parse()
         assert_matches_type(BatchArchiveResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_archive(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.batch.with_streaming_response.archive(
@@ -347,7 +322,7 @@ async def test_streaming_response_archive(self, async_client: AsyncKnock) -> Non
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
+    @pytest.mark.skip(reason="Steady does not support bracket-style array query params")
     @parametrize
     async def test_method_get_content(self, async_client: AsyncKnock) -> None:
         batch = await async_client.messages.batch.get_content(
@@ -355,7 +330,7 @@ async def test_method_get_content(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BatchGetContentResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
+    @pytest.mark.skip(reason="Steady does not support bracket-style array query params")
     @parametrize
     async def test_raw_response_get_content(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.batch.with_raw_response.get_content(
@@ -367,7 +342,7 @@ async def test_raw_response_get_content(self, async_client: AsyncKnock) -> None:
         batch = await response.parse()
         assert_matches_type(BatchGetContentResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
+    @pytest.mark.skip(reason="Steady does not support bracket-style array query params")
     @parametrize
     async def test_streaming_response_get_content(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.batch.with_streaming_response.get_content(
@@ -381,7 +356,6 @@ async def test_streaming_response_get_content(self, async_client: AsyncKnock) ->
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_as_interacted(self, async_client: AsyncKnock) -> None:
         batch = await async_client.messages.batch.mark_as_interacted(
@@ -389,7 +363,6 @@ async def test_method_mark_as_interacted(self, async_client: AsyncKnock) -> None
         )
         assert_matches_type(BatchMarkAsInteractedResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_as_interacted_with_all_params(self, async_client: AsyncKnock) -> None:
         batch = await async_client.messages.batch.mark_as_interacted(
@@ -398,7 +371,6 @@ async def test_method_mark_as_interacted_with_all_params(self, async_client: Asy
         )
         assert_matches_type(BatchMarkAsInteractedResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_as_interacted(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.batch.with_raw_response.mark_as_interacted(
@@ -410,7 +382,6 @@ async def test_raw_response_mark_as_interacted(self, async_client: AsyncKnock) -
         batch = await response.parse()
         assert_matches_type(BatchMarkAsInteractedResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_as_interacted(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.batch.with_streaming_response.mark_as_interacted(
@@ -424,7 +395,6 @@ async def test_streaming_response_mark_as_interacted(self, async_client: AsyncKn
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_as_read(self, async_client: AsyncKnock) -> None:
         batch = await async_client.messages.batch.mark_as_read(
@@ -432,7 +402,6 @@ async def test_method_mark_as_read(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BatchMarkAsReadResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_as_read(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.batch.with_raw_response.mark_as_read(
@@ -444,7 +413,6 @@ async def test_raw_response_mark_as_read(self, async_client: AsyncKnock) -> None
         batch = await response.parse()
         assert_matches_type(BatchMarkAsReadResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_as_read(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.batch.with_streaming_response.mark_as_read(
@@ -458,7 +426,6 @@ async def test_streaming_response_mark_as_read(self, async_client: AsyncKnock) -
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_as_seen(self, async_client: AsyncKnock) -> None:
         batch = await async_client.messages.batch.mark_as_seen(
@@ -466,7 +433,6 @@ async def test_method_mark_as_seen(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BatchMarkAsSeenResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_as_seen(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.batch.with_raw_response.mark_as_seen(
@@ -478,7 +444,6 @@ async def test_raw_response_mark_as_seen(self, async_client: AsyncKnock) -> None
         batch = await response.parse()
         assert_matches_type(BatchMarkAsSeenResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_as_seen(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.batch.with_streaming_response.mark_as_seen(
@@ -492,7 +457,6 @@ async def test_streaming_response_mark_as_seen(self, async_client: AsyncKnock) -
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_as_unread(self, async_client: AsyncKnock) -> None:
         batch = await async_client.messages.batch.mark_as_unread(
@@ -500,7 +464,6 @@ async def test_method_mark_as_unread(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BatchMarkAsUnreadResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_as_unread(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.batch.with_raw_response.mark_as_unread(
@@ -512,7 +475,6 @@ async def test_raw_response_mark_as_unread(self, async_client: AsyncKnock) -> No
         batch = await response.parse()
         assert_matches_type(BatchMarkAsUnreadResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_as_unread(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.batch.with_streaming_response.mark_as_unread(
@@ -526,7 +488,6 @@ async def test_streaming_response_mark_as_unread(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_as_unseen(self, async_client: AsyncKnock) -> None:
         batch = await async_client.messages.batch.mark_as_unseen(
@@ -534,7 +495,6 @@ async def test_method_mark_as_unseen(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BatchMarkAsUnseenResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_as_unseen(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.batch.with_raw_response.mark_as_unseen(
@@ -546,7 +506,6 @@ async def test_raw_response_mark_as_unseen(self, async_client: AsyncKnock) -> No
         batch = await response.parse()
         assert_matches_type(BatchMarkAsUnseenResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_as_unseen(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.batch.with_streaming_response.mark_as_unseen(
@@ -560,7 +519,6 @@ async def test_streaming_response_mark_as_unseen(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_unarchive(self, async_client: AsyncKnock) -> None:
         batch = await async_client.messages.batch.unarchive(
@@ -568,7 +526,6 @@ async def test_method_unarchive(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BatchUnarchiveResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_unarchive(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.batch.with_raw_response.unarchive(
@@ -580,7 +537,6 @@ async def test_raw_response_unarchive(self, async_client: AsyncKnock) -> None:
         batch = await response.parse()
         assert_matches_type(BatchUnarchiveResponse, batch, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_unarchive(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.batch.with_streaming_response.unarchive(
diff --git a/tests/api_resources/objects/test_bulk.py b/tests/api_resources/objects/test_bulk.py
index 78e6c780..19e636c8 100644
--- a/tests/api_resources/objects/test_bulk.py
+++ b/tests/api_resources/objects/test_bulk.py
@@ -17,7 +17,6 @@
 class TestBulk:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_delete(self, client: Knock) -> None:
         bulk = client.objects.bulk.delete(
@@ -26,7 +25,6 @@ def test_method_delete(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_delete(self, client: Knock) -> None:
         response = client.objects.bulk.with_raw_response.delete(
@@ -39,7 +37,6 @@ def test_raw_response_delete(self, client: Knock) -> None:
         bulk = response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_delete(self, client: Knock) -> None:
         with client.objects.bulk.with_streaming_response.delete(
@@ -54,7 +51,6 @@ def test_streaming_response_delete(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_delete(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -63,7 +59,6 @@ def test_path_params_delete(self, client: Knock) -> None:
                 object_ids=["obj_123", "obj_456", "obj_789"],
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_add_subscriptions(self, client: Knock) -> None:
         bulk = client.objects.bulk.add_subscriptions(
@@ -77,7 +72,6 @@ def test_method_add_subscriptions(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_add_subscriptions(self, client: Knock) -> None:
         response = client.objects.bulk.with_raw_response.add_subscriptions(
@@ -95,7 +89,6 @@ def test_raw_response_add_subscriptions(self, client: Knock) -> None:
         bulk = response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_add_subscriptions(self, client: Knock) -> None:
         with client.objects.bulk.with_streaming_response.add_subscriptions(
@@ -115,7 +108,6 @@ def test_streaming_response_add_subscriptions(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_add_subscriptions(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -129,7 +121,6 @@ def test_path_params_add_subscriptions(self, client: Knock) -> None:
                 ],
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_delete_subscriptions(self, client: Knock) -> None:
         bulk = client.objects.bulk.delete_subscriptions(
@@ -147,7 +138,6 @@ def test_method_delete_subscriptions(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_delete_subscriptions(self, client: Knock) -> None:
         response = client.objects.bulk.with_raw_response.delete_subscriptions(
@@ -169,7 +159,6 @@ def test_raw_response_delete_subscriptions(self, client: Knock) -> None:
         bulk = response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_delete_subscriptions(self, client: Knock) -> None:
         with client.objects.bulk.with_streaming_response.delete_subscriptions(
@@ -193,7 +182,6 @@ def test_streaming_response_delete_subscriptions(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_delete_subscriptions(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -211,7 +199,6 @@ def test_path_params_delete_subscriptions(self, client: Knock) -> None:
                 ],
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set(self, client: Knock) -> None:
         bulk = client.objects.bulk.set(
@@ -220,7 +207,6 @@ def test_method_set(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_set(self, client: Knock) -> None:
         response = client.objects.bulk.with_raw_response.set(
@@ -233,7 +219,6 @@ def test_raw_response_set(self, client: Knock) -> None:
         bulk = response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_set(self, client: Knock) -> None:
         with client.objects.bulk.with_streaming_response.set(
@@ -248,7 +233,6 @@ def test_streaming_response_set(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_set(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -263,7 +247,6 @@ class TestAsyncBulk:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_delete(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.objects.bulk.delete(
@@ -272,7 +255,6 @@ async def test_method_delete(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.bulk.with_raw_response.delete(
@@ -285,7 +267,6 @@ async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         bulk = await response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.bulk.with_streaming_response.delete(
@@ -300,7 +281,6 @@ async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -309,7 +289,6 @@ async def test_path_params_delete(self, async_client: AsyncKnock) -> None:
                 object_ids=["obj_123", "obj_456", "obj_789"],
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_add_subscriptions(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.objects.bulk.add_subscriptions(
@@ -323,7 +302,6 @@ async def test_method_add_subscriptions(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_add_subscriptions(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.bulk.with_raw_response.add_subscriptions(
@@ -341,7 +319,6 @@ async def test_raw_response_add_subscriptions(self, async_client: AsyncKnock) ->
         bulk = await response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_add_subscriptions(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.bulk.with_streaming_response.add_subscriptions(
@@ -361,7 +338,6 @@ async def test_streaming_response_add_subscriptions(self, async_client: AsyncKno
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_add_subscriptions(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -375,7 +351,6 @@ async def test_path_params_add_subscriptions(self, async_client: AsyncKnock) ->
                 ],
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_delete_subscriptions(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.objects.bulk.delete_subscriptions(
@@ -393,7 +368,6 @@ async def test_method_delete_subscriptions(self, async_client: AsyncKnock) -> No
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_delete_subscriptions(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.bulk.with_raw_response.delete_subscriptions(
@@ -415,7 +389,6 @@ async def test_raw_response_delete_subscriptions(self, async_client: AsyncKnock)
         bulk = await response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_delete_subscriptions(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.bulk.with_streaming_response.delete_subscriptions(
@@ -439,7 +412,6 @@ async def test_streaming_response_delete_subscriptions(self, async_client: Async
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_delete_subscriptions(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -457,7 +429,6 @@ async def test_path_params_delete_subscriptions(self, async_client: AsyncKnock)
                 ],
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.objects.bulk.set(
@@ -466,7 +437,6 @@ async def test_method_set(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_set(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.bulk.with_raw_response.set(
@@ -479,7 +449,6 @@ async def test_raw_response_set(self, async_client: AsyncKnock) -> None:
         bulk = await response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_set(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.bulk.with_streaming_response.set(
@@ -494,7 +463,6 @@ async def test_streaming_response_set(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_set(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
diff --git a/tests/api_resources/providers/test_ms_teams.py b/tests/api_resources/providers/test_ms_teams.py
index 1a0f9cb1..eb8daf03 100644
--- a/tests/api_resources/providers/test_ms_teams.py
+++ b/tests/api_resources/providers/test_ms_teams.py
@@ -23,7 +23,6 @@
 class TestMsTeams:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_check_auth(self, client: Knock) -> None:
         ms_team = client.providers.ms_teams.check_auth(
@@ -32,7 +31,6 @@ def test_method_check_auth(self, client: Knock) -> None:
         )
         assert_matches_type(MsTeamCheckAuthResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_check_auth(self, client: Knock) -> None:
         response = client.providers.ms_teams.with_raw_response.check_auth(
@@ -45,7 +43,6 @@ def test_raw_response_check_auth(self, client: Knock) -> None:
         ms_team = response.parse()
         assert_matches_type(MsTeamCheckAuthResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_check_auth(self, client: Knock) -> None:
         with client.providers.ms_teams.with_streaming_response.check_auth(
@@ -60,7 +57,6 @@ def test_streaming_response_check_auth(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_check_auth(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -69,7 +65,6 @@ def test_path_params_check_auth(self, client: Knock) -> None:
                 ms_teams_tenant_object="ms_teams_tenant_object",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_channels(self, client: Knock) -> None:
         ms_team = client.providers.ms_teams.list_channels(
@@ -79,7 +74,6 @@ def test_method_list_channels(self, client: Knock) -> None:
         )
         assert_matches_type(MsTeamListChannelsResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_channels_with_all_params(self, client: Knock) -> None:
         ms_team = client.providers.ms_teams.list_channels(
@@ -93,7 +87,6 @@ def test_method_list_channels_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(MsTeamListChannelsResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_channels(self, client: Knock) -> None:
         response = client.providers.ms_teams.with_raw_response.list_channels(
@@ -107,7 +100,6 @@ def test_raw_response_list_channels(self, client: Knock) -> None:
         ms_team = response.parse()
         assert_matches_type(MsTeamListChannelsResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_channels(self, client: Knock) -> None:
         with client.providers.ms_teams.with_streaming_response.list_channels(
@@ -123,7 +115,6 @@ def test_streaming_response_list_channels(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_channels(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -133,7 +124,6 @@ def test_path_params_list_channels(self, client: Knock) -> None:
                 team_id="team_id",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_teams(self, client: Knock) -> None:
         ms_team = client.providers.ms_teams.list_teams(
@@ -142,7 +132,6 @@ def test_method_list_teams(self, client: Knock) -> None:
         )
         assert_matches_type(SyncMsTeamsPagination[MsTeamListTeamsResponse], ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_teams_with_all_params(self, client: Knock) -> None:
         ms_team = client.providers.ms_teams.list_teams(
@@ -157,7 +146,6 @@ def test_method_list_teams_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncMsTeamsPagination[MsTeamListTeamsResponse], ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_teams(self, client: Knock) -> None:
         response = client.providers.ms_teams.with_raw_response.list_teams(
@@ -170,7 +158,6 @@ def test_raw_response_list_teams(self, client: Knock) -> None:
         ms_team = response.parse()
         assert_matches_type(SyncMsTeamsPagination[MsTeamListTeamsResponse], ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_teams(self, client: Knock) -> None:
         with client.providers.ms_teams.with_streaming_response.list_teams(
@@ -185,7 +172,6 @@ def test_streaming_response_list_teams(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_teams(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -194,7 +180,6 @@ def test_path_params_list_teams(self, client: Knock) -> None:
                 ms_teams_tenant_object="ms_teams_tenant_object",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_revoke_access(self, client: Knock) -> None:
         ms_team = client.providers.ms_teams.revoke_access(
@@ -203,7 +188,6 @@ def test_method_revoke_access(self, client: Knock) -> None:
         )
         assert_matches_type(MsTeamRevokeAccessResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_revoke_access(self, client: Knock) -> None:
         response = client.providers.ms_teams.with_raw_response.revoke_access(
@@ -216,7 +200,6 @@ def test_raw_response_revoke_access(self, client: Knock) -> None:
         ms_team = response.parse()
         assert_matches_type(MsTeamRevokeAccessResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_revoke_access(self, client: Knock) -> None:
         with client.providers.ms_teams.with_streaming_response.revoke_access(
@@ -231,7 +214,6 @@ def test_streaming_response_revoke_access(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_revoke_access(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -246,7 +228,6 @@ class TestAsyncMsTeams:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_check_auth(self, async_client: AsyncKnock) -> None:
         ms_team = await async_client.providers.ms_teams.check_auth(
@@ -255,7 +236,6 @@ async def test_method_check_auth(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(MsTeamCheckAuthResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_check_auth(self, async_client: AsyncKnock) -> None:
         response = await async_client.providers.ms_teams.with_raw_response.check_auth(
@@ -268,7 +248,6 @@ async def test_raw_response_check_auth(self, async_client: AsyncKnock) -> None:
         ms_team = await response.parse()
         assert_matches_type(MsTeamCheckAuthResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_check_auth(self, async_client: AsyncKnock) -> None:
         async with async_client.providers.ms_teams.with_streaming_response.check_auth(
@@ -283,7 +262,6 @@ async def test_streaming_response_check_auth(self, async_client: AsyncKnock) ->
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_check_auth(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -292,7 +270,6 @@ async def test_path_params_check_auth(self, async_client: AsyncKnock) -> None:
                 ms_teams_tenant_object="ms_teams_tenant_object",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_channels(self, async_client: AsyncKnock) -> None:
         ms_team = await async_client.providers.ms_teams.list_channels(
@@ -302,7 +279,6 @@ async def test_method_list_channels(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(MsTeamListChannelsResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_channels_with_all_params(self, async_client: AsyncKnock) -> None:
         ms_team = await async_client.providers.ms_teams.list_channels(
@@ -316,7 +292,6 @@ async def test_method_list_channels_with_all_params(self, async_client: AsyncKno
         )
         assert_matches_type(MsTeamListChannelsResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_channels(self, async_client: AsyncKnock) -> None:
         response = await async_client.providers.ms_teams.with_raw_response.list_channels(
@@ -330,7 +305,6 @@ async def test_raw_response_list_channels(self, async_client: AsyncKnock) -> Non
         ms_team = await response.parse()
         assert_matches_type(MsTeamListChannelsResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_channels(self, async_client: AsyncKnock) -> None:
         async with async_client.providers.ms_teams.with_streaming_response.list_channels(
@@ -346,7 +320,6 @@ async def test_streaming_response_list_channels(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_channels(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -356,7 +329,6 @@ async def test_path_params_list_channels(self, async_client: AsyncKnock) -> None
                 team_id="team_id",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_teams(self, async_client: AsyncKnock) -> None:
         ms_team = await async_client.providers.ms_teams.list_teams(
@@ -365,7 +337,6 @@ async def test_method_list_teams(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(AsyncMsTeamsPagination[MsTeamListTeamsResponse], ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_teams_with_all_params(self, async_client: AsyncKnock) -> None:
         ms_team = await async_client.providers.ms_teams.list_teams(
@@ -380,7 +351,6 @@ async def test_method_list_teams_with_all_params(self, async_client: AsyncKnock)
         )
         assert_matches_type(AsyncMsTeamsPagination[MsTeamListTeamsResponse], ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_teams(self, async_client: AsyncKnock) -> None:
         response = await async_client.providers.ms_teams.with_raw_response.list_teams(
@@ -393,7 +363,6 @@ async def test_raw_response_list_teams(self, async_client: AsyncKnock) -> None:
         ms_team = await response.parse()
         assert_matches_type(AsyncMsTeamsPagination[MsTeamListTeamsResponse], ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_teams(self, async_client: AsyncKnock) -> None:
         async with async_client.providers.ms_teams.with_streaming_response.list_teams(
@@ -408,7 +377,6 @@ async def test_streaming_response_list_teams(self, async_client: AsyncKnock) ->
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_teams(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -417,7 +385,6 @@ async def test_path_params_list_teams(self, async_client: AsyncKnock) -> None:
                 ms_teams_tenant_object="ms_teams_tenant_object",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_revoke_access(self, async_client: AsyncKnock) -> None:
         ms_team = await async_client.providers.ms_teams.revoke_access(
@@ -426,7 +393,6 @@ async def test_method_revoke_access(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(MsTeamRevokeAccessResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_revoke_access(self, async_client: AsyncKnock) -> None:
         response = await async_client.providers.ms_teams.with_raw_response.revoke_access(
@@ -439,7 +405,6 @@ async def test_raw_response_revoke_access(self, async_client: AsyncKnock) -> Non
         ms_team = await response.parse()
         assert_matches_type(MsTeamRevokeAccessResponse, ms_team, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_revoke_access(self, async_client: AsyncKnock) -> None:
         async with async_client.providers.ms_teams.with_streaming_response.revoke_access(
@@ -454,7 +419,6 @@ async def test_streaming_response_revoke_access(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_revoke_access(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
diff --git a/tests/api_resources/providers/test_slack.py b/tests/api_resources/providers/test_slack.py
index a0e993d8..fd85e507 100644
--- a/tests/api_resources/providers/test_slack.py
+++ b/tests/api_resources/providers/test_slack.py
@@ -22,7 +22,6 @@
 class TestSlack:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_check_auth(self, client: Knock) -> None:
         slack = client.providers.slack.check_auth(
@@ -31,7 +30,6 @@ def test_method_check_auth(self, client: Knock) -> None:
         )
         assert_matches_type(SlackCheckAuthResponse, slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_check_auth(self, client: Knock) -> None:
         response = client.providers.slack.with_raw_response.check_auth(
@@ -44,7 +42,6 @@ def test_raw_response_check_auth(self, client: Knock) -> None:
         slack = response.parse()
         assert_matches_type(SlackCheckAuthResponse, slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_check_auth(self, client: Knock) -> None:
         with client.providers.slack.with_streaming_response.check_auth(
@@ -59,7 +56,6 @@ def test_streaming_response_check_auth(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_check_auth(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -68,7 +64,6 @@ def test_path_params_check_auth(self, client: Knock) -> None:
                 access_token_object="access_token_object",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_channels(self, client: Knock) -> None:
         slack = client.providers.slack.list_channels(
@@ -77,7 +72,6 @@ def test_method_list_channels(self, client: Knock) -> None:
         )
         assert_matches_type(SyncSlackChannelsCursor[SlackListChannelsResponse], slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_channels_with_all_params(self, client: Knock) -> None:
         slack = client.providers.slack.list_channels(
@@ -93,7 +87,6 @@ def test_method_list_channels_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncSlackChannelsCursor[SlackListChannelsResponse], slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_channels(self, client: Knock) -> None:
         response = client.providers.slack.with_raw_response.list_channels(
@@ -106,7 +99,6 @@ def test_raw_response_list_channels(self, client: Knock) -> None:
         slack = response.parse()
         assert_matches_type(SyncSlackChannelsCursor[SlackListChannelsResponse], slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_channels(self, client: Knock) -> None:
         with client.providers.slack.with_streaming_response.list_channels(
@@ -121,7 +113,6 @@ def test_streaming_response_list_channels(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_channels(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -130,7 +121,6 @@ def test_path_params_list_channels(self, client: Knock) -> None:
                 access_token_object="access_token_object",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_revoke_access(self, client: Knock) -> None:
         slack = client.providers.slack.revoke_access(
@@ -139,7 +129,6 @@ def test_method_revoke_access(self, client: Knock) -> None:
         )
         assert_matches_type(SlackRevokeAccessResponse, slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_revoke_access(self, client: Knock) -> None:
         response = client.providers.slack.with_raw_response.revoke_access(
@@ -152,7 +141,6 @@ def test_raw_response_revoke_access(self, client: Knock) -> None:
         slack = response.parse()
         assert_matches_type(SlackRevokeAccessResponse, slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_revoke_access(self, client: Knock) -> None:
         with client.providers.slack.with_streaming_response.revoke_access(
@@ -167,7 +155,6 @@ def test_streaming_response_revoke_access(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_revoke_access(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -182,7 +169,6 @@ class TestAsyncSlack:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_check_auth(self, async_client: AsyncKnock) -> None:
         slack = await async_client.providers.slack.check_auth(
@@ -191,7 +177,6 @@ async def test_method_check_auth(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(SlackCheckAuthResponse, slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_check_auth(self, async_client: AsyncKnock) -> None:
         response = await async_client.providers.slack.with_raw_response.check_auth(
@@ -204,7 +189,6 @@ async def test_raw_response_check_auth(self, async_client: AsyncKnock) -> None:
         slack = await response.parse()
         assert_matches_type(SlackCheckAuthResponse, slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_check_auth(self, async_client: AsyncKnock) -> None:
         async with async_client.providers.slack.with_streaming_response.check_auth(
@@ -219,7 +203,6 @@ async def test_streaming_response_check_auth(self, async_client: AsyncKnock) ->
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_check_auth(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -228,7 +211,6 @@ async def test_path_params_check_auth(self, async_client: AsyncKnock) -> None:
                 access_token_object="access_token_object",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_channels(self, async_client: AsyncKnock) -> None:
         slack = await async_client.providers.slack.list_channels(
@@ -237,7 +219,6 @@ async def test_method_list_channels(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(AsyncSlackChannelsCursor[SlackListChannelsResponse], slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_channels_with_all_params(self, async_client: AsyncKnock) -> None:
         slack = await async_client.providers.slack.list_channels(
@@ -253,7 +234,6 @@ async def test_method_list_channels_with_all_params(self, async_client: AsyncKno
         )
         assert_matches_type(AsyncSlackChannelsCursor[SlackListChannelsResponse], slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_channels(self, async_client: AsyncKnock) -> None:
         response = await async_client.providers.slack.with_raw_response.list_channels(
@@ -266,7 +246,6 @@ async def test_raw_response_list_channels(self, async_client: AsyncKnock) -> Non
         slack = await response.parse()
         assert_matches_type(AsyncSlackChannelsCursor[SlackListChannelsResponse], slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_channels(self, async_client: AsyncKnock) -> None:
         async with async_client.providers.slack.with_streaming_response.list_channels(
@@ -281,7 +260,6 @@ async def test_streaming_response_list_channels(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_channels(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
@@ -290,7 +268,6 @@ async def test_path_params_list_channels(self, async_client: AsyncKnock) -> None
                 access_token_object="access_token_object",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_revoke_access(self, async_client: AsyncKnock) -> None:
         slack = await async_client.providers.slack.revoke_access(
@@ -299,7 +276,6 @@ async def test_method_revoke_access(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(SlackRevokeAccessResponse, slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_revoke_access(self, async_client: AsyncKnock) -> None:
         response = await async_client.providers.slack.with_raw_response.revoke_access(
@@ -312,7 +288,6 @@ async def test_raw_response_revoke_access(self, async_client: AsyncKnock) -> Non
         slack = await response.parse()
         assert_matches_type(SlackRevokeAccessResponse, slack, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_revoke_access(self, async_client: AsyncKnock) -> None:
         async with async_client.providers.slack.with_streaming_response.revoke_access(
@@ -327,7 +302,6 @@ async def test_streaming_response_revoke_access(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_revoke_access(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `channel_id` but received ''"):
diff --git a/tests/api_resources/schedules/test_bulk.py b/tests/api_resources/schedules/test_bulk.py
index d2426efc..93076263 100644
--- a/tests/api_resources/schedules/test_bulk.py
+++ b/tests/api_resources/schedules/test_bulk.py
@@ -17,7 +17,6 @@
 class TestBulk:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_create(self, client: Knock) -> None:
         bulk = client.schedules.bulk.create(
@@ -25,7 +24,6 @@ def test_method_create(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_create(self, client: Knock) -> None:
         response = client.schedules.bulk.with_raw_response.create(
@@ -37,7 +35,6 @@ def test_raw_response_create(self, client: Knock) -> None:
         bulk = response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_create(self, client: Knock) -> None:
         with client.schedules.bulk.with_streaming_response.create(
@@ -57,7 +54,6 @@ class TestAsyncBulk:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_create(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.schedules.bulk.create(
@@ -65,7 +61,6 @@ async def test_method_create(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncKnock) -> None:
         response = await async_client.schedules.bulk.with_raw_response.create(
@@ -77,7 +72,6 @@ async def test_raw_response_create(self, async_client: AsyncKnock) -> None:
         bulk = await response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncKnock) -> None:
         async with async_client.schedules.bulk.with_streaming_response.create(
diff --git a/tests/api_resources/tenants/test_bulk.py b/tests/api_resources/tenants/test_bulk.py
index 22096bea..58a4d9b7 100644
--- a/tests/api_resources/tenants/test_bulk.py
+++ b/tests/api_resources/tenants/test_bulk.py
@@ -17,7 +17,7 @@
 class TestBulk:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
+    @pytest.mark.skip(reason="Steady does not support bracket-style array query params")
     @parametrize
     def test_method_delete(self, client: Knock) -> None:
         bulk = client.tenants.bulk.delete(
@@ -25,7 +25,7 @@ def test_method_delete(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
+    @pytest.mark.skip(reason="Steady does not support bracket-style array query params")
     @parametrize
     def test_raw_response_delete(self, client: Knock) -> None:
         response = client.tenants.bulk.with_raw_response.delete(
@@ -37,7 +37,7 @@ def test_raw_response_delete(self, client: Knock) -> None:
         bulk = response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
+    @pytest.mark.skip(reason="Steady does not support bracket-style array query params")
     @parametrize
     def test_streaming_response_delete(self, client: Knock) -> None:
         with client.tenants.bulk.with_streaming_response.delete(
@@ -51,7 +51,6 @@ def test_streaming_response_delete(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set(self, client: Knock) -> None:
         bulk = client.tenants.bulk.set(
@@ -59,7 +58,6 @@ def test_method_set(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_set(self, client: Knock) -> None:
         response = client.tenants.bulk.with_raw_response.set(
@@ -71,7 +69,6 @@ def test_raw_response_set(self, client: Knock) -> None:
         bulk = response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_set(self, client: Knock) -> None:
         with client.tenants.bulk.with_streaming_response.set(
@@ -91,7 +88,7 @@ class TestAsyncBulk:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
+    @pytest.mark.skip(reason="Steady does not support bracket-style array query params")
     @parametrize
     async def test_method_delete(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.tenants.bulk.delete(
@@ -99,7 +96,7 @@ async def test_method_delete(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
+    @pytest.mark.skip(reason="Steady does not support bracket-style array query params")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         response = await async_client.tenants.bulk.with_raw_response.delete(
@@ -111,7 +108,7 @@ async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         bulk = await response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
+    @pytest.mark.skip(reason="Steady does not support bracket-style array query params")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None:
         async with async_client.tenants.bulk.with_streaming_response.delete(
@@ -125,7 +122,6 @@ async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.tenants.bulk.set(
@@ -133,7 +129,6 @@ async def test_method_set(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_set(self, async_client: AsyncKnock) -> None:
         response = await async_client.tenants.bulk.with_raw_response.set(
@@ -145,7 +140,6 @@ async def test_raw_response_set(self, async_client: AsyncKnock) -> None:
         bulk = await response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_set(self, async_client: AsyncKnock) -> None:
         async with async_client.tenants.bulk.with_streaming_response.set(
diff --git a/tests/api_resources/test_audiences.py b/tests/api_resources/test_audiences.py
index 26dcb10e..43ff772c 100644
--- a/tests/api_resources/test_audiences.py
+++ b/tests/api_resources/test_audiences.py
@@ -18,7 +18,6 @@
 class TestAudiences:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_add_members(self, client: Knock) -> None:
         audience = client.audiences.add_members(
@@ -27,7 +26,6 @@ def test_method_add_members(self, client: Knock) -> None:
         )
         assert audience is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_add_members_with_all_params(self, client: Knock) -> None:
         audience = client.audiences.add_members(
@@ -50,11 +48,43 @@ def test_method_add_members_with_all_params(self, client: Knock) -> None:
                                     "marketing": False,
                                     "transactional": {
                                         "channel_types": {
-                                            "chat": True,
+                                            "chat": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
                                             "email": False,
-                                            "http": True,
-                                            "in_app_feed": True,
-                                            "push": True,
+                                            "http": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
+                                            "in_app_feed": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
+                                            "push": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
                                             "sms": {
                                                 "conditions": [
                                                     {
@@ -76,11 +106,43 @@ def test_method_add_members_with_all_params(self, client: Knock) -> None:
                                     },
                                 },
                                 "channel_types": {
-                                    "chat": True,
+                                    "chat": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
                                     "email": True,
-                                    "http": True,
-                                    "in_app_feed": True,
-                                    "push": True,
+                                    "http": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
+                                    "in_app_feed": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
+                                    "push": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
                                     "sms": {
                                         "conditions": [
                                             {
@@ -107,11 +169,43 @@ def test_method_add_members_with_all_params(self, client: Knock) -> None:
                                 "workflows": {
                                     "dinosaurs-loose": {
                                         "channel_types": {
-                                            "chat": True,
+                                            "chat": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
                                             "email": True,
-                                            "http": True,
-                                            "in_app_feed": True,
-                                            "push": True,
+                                            "http": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
+                                            "in_app_feed": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
+                                            "push": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
                                             "sms": {
                                                 "conditions": [
                                                     {
@@ -143,7 +237,6 @@ def test_method_add_members_with_all_params(self, client: Knock) -> None:
         )
         assert audience is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_add_members(self, client: Knock) -> None:
         response = client.audiences.with_raw_response.add_members(
@@ -156,7 +249,6 @@ def test_raw_response_add_members(self, client: Knock) -> None:
         audience = response.parse()
         assert audience is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_add_members(self, client: Knock) -> None:
         with client.audiences.with_streaming_response.add_members(
@@ -171,7 +263,6 @@ def test_streaming_response_add_members(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_add_members(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"):
@@ -180,7 +271,6 @@ def test_path_params_add_members(self, client: Knock) -> None:
                 members=[{"user": {"id": "dr_sattler"}}],
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_members(self, client: Knock) -> None:
         audience = client.audiences.list_members(
@@ -188,7 +278,6 @@ def test_method_list_members(self, client: Knock) -> None:
         )
         assert_matches_type(AudienceListMembersResponse, audience, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_members(self, client: Knock) -> None:
         response = client.audiences.with_raw_response.list_members(
@@ -200,7 +289,6 @@ def test_raw_response_list_members(self, client: Knock) -> None:
         audience = response.parse()
         assert_matches_type(AudienceListMembersResponse, audience, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_members(self, client: Knock) -> None:
         with client.audiences.with_streaming_response.list_members(
@@ -214,7 +302,6 @@ def test_streaming_response_list_members(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_members(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"):
@@ -222,7 +309,6 @@ def test_path_params_list_members(self, client: Knock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_remove_members(self, client: Knock) -> None:
         audience = client.audiences.remove_members(
@@ -231,7 +317,6 @@ def test_method_remove_members(self, client: Knock) -> None:
         )
         assert audience is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_remove_members(self, client: Knock) -> None:
         response = client.audiences.with_raw_response.remove_members(
@@ -244,7 +329,6 @@ def test_raw_response_remove_members(self, client: Knock) -> None:
         audience = response.parse()
         assert audience is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_remove_members(self, client: Knock) -> None:
         with client.audiences.with_streaming_response.remove_members(
@@ -259,7 +343,6 @@ def test_streaming_response_remove_members(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_remove_members(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"):
@@ -274,7 +357,6 @@ class TestAsyncAudiences:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_add_members(self, async_client: AsyncKnock) -> None:
         audience = await async_client.audiences.add_members(
@@ -283,7 +365,6 @@ async def test_method_add_members(self, async_client: AsyncKnock) -> None:
         )
         assert audience is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_add_members_with_all_params(self, async_client: AsyncKnock) -> None:
         audience = await async_client.audiences.add_members(
@@ -306,11 +387,43 @@ async def test_method_add_members_with_all_params(self, async_client: AsyncKnock
                                     "marketing": False,
                                     "transactional": {
                                         "channel_types": {
-                                            "chat": True,
+                                            "chat": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
                                             "email": False,
-                                            "http": True,
-                                            "in_app_feed": True,
-                                            "push": True,
+                                            "http": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
+                                            "in_app_feed": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
+                                            "push": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
                                             "sms": {
                                                 "conditions": [
                                                     {
@@ -332,11 +445,43 @@ async def test_method_add_members_with_all_params(self, async_client: AsyncKnock
                                     },
                                 },
                                 "channel_types": {
-                                    "chat": True,
+                                    "chat": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
                                     "email": True,
-                                    "http": True,
-                                    "in_app_feed": True,
-                                    "push": True,
+                                    "http": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
+                                    "in_app_feed": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
+                                    "push": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
                                     "sms": {
                                         "conditions": [
                                             {
@@ -363,11 +508,43 @@ async def test_method_add_members_with_all_params(self, async_client: AsyncKnock
                                 "workflows": {
                                     "dinosaurs-loose": {
                                         "channel_types": {
-                                            "chat": True,
+                                            "chat": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
                                             "email": True,
-                                            "http": True,
-                                            "in_app_feed": True,
-                                            "push": True,
+                                            "http": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
+                                            "in_app_feed": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
+                                            "push": {
+                                                "conditions": [
+                                                    {
+                                                        "argument": "US",
+                                                        "operator": "equal_to",
+                                                        "variable": "recipient.country_code",
+                                                    }
+                                                ]
+                                            },
                                             "sms": {
                                                 "conditions": [
                                                     {
@@ -399,7 +576,6 @@ async def test_method_add_members_with_all_params(self, async_client: AsyncKnock
         )
         assert audience is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_add_members(self, async_client: AsyncKnock) -> None:
         response = await async_client.audiences.with_raw_response.add_members(
@@ -412,7 +588,6 @@ async def test_raw_response_add_members(self, async_client: AsyncKnock) -> None:
         audience = await response.parse()
         assert audience is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_add_members(self, async_client: AsyncKnock) -> None:
         async with async_client.audiences.with_streaming_response.add_members(
@@ -427,7 +602,6 @@ async def test_streaming_response_add_members(self, async_client: AsyncKnock) ->
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_add_members(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"):
@@ -436,7 +610,6 @@ async def test_path_params_add_members(self, async_client: AsyncKnock) -> None:
                 members=[{"user": {"id": "dr_sattler"}}],
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_members(self, async_client: AsyncKnock) -> None:
         audience = await async_client.audiences.list_members(
@@ -444,7 +617,6 @@ async def test_method_list_members(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(AudienceListMembersResponse, audience, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_members(self, async_client: AsyncKnock) -> None:
         response = await async_client.audiences.with_raw_response.list_members(
@@ -456,7 +628,6 @@ async def test_raw_response_list_members(self, async_client: AsyncKnock) -> None
         audience = await response.parse()
         assert_matches_type(AudienceListMembersResponse, audience, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_members(self, async_client: AsyncKnock) -> None:
         async with async_client.audiences.with_streaming_response.list_members(
@@ -470,7 +641,6 @@ async def test_streaming_response_list_members(self, async_client: AsyncKnock) -
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_members(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"):
@@ -478,7 +648,6 @@ async def test_path_params_list_members(self, async_client: AsyncKnock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_remove_members(self, async_client: AsyncKnock) -> None:
         audience = await async_client.audiences.remove_members(
@@ -487,7 +656,6 @@ async def test_method_remove_members(self, async_client: AsyncKnock) -> None:
         )
         assert audience is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_remove_members(self, async_client: AsyncKnock) -> None:
         response = await async_client.audiences.with_raw_response.remove_members(
@@ -500,7 +668,6 @@ async def test_raw_response_remove_members(self, async_client: AsyncKnock) -> No
         audience = await response.parse()
         assert audience is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_remove_members(self, async_client: AsyncKnock) -> None:
         async with async_client.audiences.with_streaming_response.remove_members(
@@ -515,7 +682,6 @@ async def test_streaming_response_remove_members(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_remove_members(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"):
diff --git a/tests/api_resources/test_bulk_operations.py b/tests/api_resources/test_bulk_operations.py
index a38e091b..2b764216 100644
--- a/tests/api_resources/test_bulk_operations.py
+++ b/tests/api_resources/test_bulk_operations.py
@@ -17,7 +17,6 @@
 class TestBulkOperations:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get(self, client: Knock) -> None:
         bulk_operation = client.bulk_operations.get(
@@ -25,7 +24,6 @@ def test_method_get(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk_operation, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_get(self, client: Knock) -> None:
         response = client.bulk_operations.with_raw_response.get(
@@ -37,7 +35,6 @@ def test_raw_response_get(self, client: Knock) -> None:
         bulk_operation = response.parse()
         assert_matches_type(BulkOperation, bulk_operation, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_get(self, client: Knock) -> None:
         with client.bulk_operations.with_streaming_response.get(
@@ -51,7 +48,6 @@ def test_streaming_response_get(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_get(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
@@ -65,7 +61,6 @@ class TestAsyncBulkOperations:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get(self, async_client: AsyncKnock) -> None:
         bulk_operation = await async_client.bulk_operations.get(
@@ -73,7 +68,6 @@ async def test_method_get(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BulkOperation, bulk_operation, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_get(self, async_client: AsyncKnock) -> None:
         response = await async_client.bulk_operations.with_raw_response.get(
@@ -85,7 +79,6 @@ async def test_raw_response_get(self, async_client: AsyncKnock) -> None:
         bulk_operation = await response.parse()
         assert_matches_type(BulkOperation, bulk_operation, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_get(self, async_client: AsyncKnock) -> None:
         async with async_client.bulk_operations.with_streaming_response.get(
@@ -99,7 +92,6 @@ async def test_streaming_response_get(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_get(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py
index 3225f70f..79f9ddd0 100644
--- a/tests/api_resources/test_messages.py
+++ b/tests/api_resources/test_messages.py
@@ -24,13 +24,11 @@
 class TestMessages:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list(self, client: Knock) -> None:
         message = client.messages.list()
         assert_matches_type(SyncItemsCursor[Message], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_with_all_params(self, client: Knock) -> None:
         message = client.messages.list(
@@ -56,7 +54,6 @@ def test_method_list_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncItemsCursor[Message], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list(self, client: Knock) -> None:
         response = client.messages.with_raw_response.list()
@@ -66,7 +63,6 @@ def test_raw_response_list(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(SyncItemsCursor[Message], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list(self, client: Knock) -> None:
         with client.messages.with_streaming_response.list() as response:
@@ -78,7 +74,6 @@ def test_streaming_response_list(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_archive(self, client: Knock) -> None:
         message = client.messages.archive(
@@ -86,7 +81,6 @@ def test_method_archive(self, client: Knock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_archive(self, client: Knock) -> None:
         response = client.messages.with_raw_response.archive(
@@ -98,7 +92,6 @@ def test_raw_response_archive(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_archive(self, client: Knock) -> None:
         with client.messages.with_streaming_response.archive(
@@ -112,7 +105,6 @@ def test_streaming_response_archive(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_archive(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -120,7 +112,6 @@ def test_path_params_archive(self, client: Knock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get(self, client: Knock) -> None:
         message = client.messages.get(
@@ -128,7 +119,6 @@ def test_method_get(self, client: Knock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_get(self, client: Knock) -> None:
         response = client.messages.with_raw_response.get(
@@ -140,7 +130,6 @@ def test_raw_response_get(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_get(self, client: Knock) -> None:
         with client.messages.with_streaming_response.get(
@@ -154,7 +143,6 @@ def test_streaming_response_get(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_get(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -162,7 +150,6 @@ def test_path_params_get(self, client: Knock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get_content(self, client: Knock) -> None:
         message = client.messages.get_content(
@@ -170,7 +157,6 @@ def test_method_get_content(self, client: Knock) -> None:
         )
         assert_matches_type(MessageGetContentResponse, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_get_content(self, client: Knock) -> None:
         response = client.messages.with_raw_response.get_content(
@@ -182,7 +168,6 @@ def test_raw_response_get_content(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(MessageGetContentResponse, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_get_content(self, client: Knock) -> None:
         with client.messages.with_streaming_response.get_content(
@@ -196,7 +181,6 @@ def test_streaming_response_get_content(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_get_content(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -204,7 +188,6 @@ def test_path_params_get_content(self, client: Knock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_activities(self, client: Knock) -> None:
         message = client.messages.list_activities(
@@ -212,7 +195,6 @@ def test_method_list_activities(self, client: Knock) -> None:
         )
         assert_matches_type(SyncItemsCursor[Activity], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_activities_with_all_params(self, client: Knock) -> None:
         message = client.messages.list_activities(
@@ -224,7 +206,6 @@ def test_method_list_activities_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncItemsCursor[Activity], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_activities(self, client: Knock) -> None:
         response = client.messages.with_raw_response.list_activities(
@@ -236,7 +217,6 @@ def test_raw_response_list_activities(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(SyncItemsCursor[Activity], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_activities(self, client: Knock) -> None:
         with client.messages.with_streaming_response.list_activities(
@@ -250,7 +230,6 @@ def test_streaming_response_list_activities(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_activities(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -258,7 +237,6 @@ def test_path_params_list_activities(self, client: Knock) -> None:
                 message_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_delivery_logs(self, client: Knock) -> None:
         message = client.messages.list_delivery_logs(
@@ -266,7 +244,6 @@ def test_method_list_delivery_logs(self, client: Knock) -> None:
         )
         assert_matches_type(SyncItemsCursor[MessageDeliveryLog], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_delivery_logs_with_all_params(self, client: Knock) -> None:
         message = client.messages.list_delivery_logs(
@@ -277,7 +254,6 @@ def test_method_list_delivery_logs_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncItemsCursor[MessageDeliveryLog], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_delivery_logs(self, client: Knock) -> None:
         response = client.messages.with_raw_response.list_delivery_logs(
@@ -289,7 +265,6 @@ def test_raw_response_list_delivery_logs(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(SyncItemsCursor[MessageDeliveryLog], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_delivery_logs(self, client: Knock) -> None:
         with client.messages.with_streaming_response.list_delivery_logs(
@@ -303,7 +278,6 @@ def test_streaming_response_list_delivery_logs(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_delivery_logs(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -311,7 +285,6 @@ def test_path_params_list_delivery_logs(self, client: Knock) -> None:
                 message_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_events(self, client: Knock) -> None:
         message = client.messages.list_events(
@@ -319,7 +292,6 @@ def test_method_list_events(self, client: Knock) -> None:
         )
         assert_matches_type(SyncItemsCursor[MessageEvent], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_events_with_all_params(self, client: Knock) -> None:
         message = client.messages.list_events(
@@ -330,7 +302,6 @@ def test_method_list_events_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncItemsCursor[MessageEvent], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_events(self, client: Knock) -> None:
         response = client.messages.with_raw_response.list_events(
@@ -342,7 +313,6 @@ def test_raw_response_list_events(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(SyncItemsCursor[MessageEvent], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_events(self, client: Knock) -> None:
         with client.messages.with_streaming_response.list_events(
@@ -356,7 +326,6 @@ def test_streaming_response_list_events(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_events(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -364,7 +333,6 @@ def test_path_params_list_events(self, client: Knock) -> None:
                 message_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_as_interacted(self, client: Knock) -> None:
         message = client.messages.mark_as_interacted(
@@ -372,7 +340,6 @@ def test_method_mark_as_interacted(self, client: Knock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_as_interacted_with_all_params(self, client: Knock) -> None:
         message = client.messages.mark_as_interacted(
@@ -381,7 +348,6 @@ def test_method_mark_as_interacted_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_as_interacted(self, client: Knock) -> None:
         response = client.messages.with_raw_response.mark_as_interacted(
@@ -393,7 +359,6 @@ def test_raw_response_mark_as_interacted(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_as_interacted(self, client: Knock) -> None:
         with client.messages.with_streaming_response.mark_as_interacted(
@@ -407,7 +372,6 @@ def test_streaming_response_mark_as_interacted(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_mark_as_interacted(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -415,7 +379,6 @@ def test_path_params_mark_as_interacted(self, client: Knock) -> None:
                 message_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_as_read(self, client: Knock) -> None:
         message = client.messages.mark_as_read(
@@ -423,7 +386,6 @@ def test_method_mark_as_read(self, client: Knock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_as_read(self, client: Knock) -> None:
         response = client.messages.with_raw_response.mark_as_read(
@@ -435,7 +397,6 @@ def test_raw_response_mark_as_read(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_as_read(self, client: Knock) -> None:
         with client.messages.with_streaming_response.mark_as_read(
@@ -449,7 +410,6 @@ def test_streaming_response_mark_as_read(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_mark_as_read(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -457,7 +417,6 @@ def test_path_params_mark_as_read(self, client: Knock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_as_seen(self, client: Knock) -> None:
         message = client.messages.mark_as_seen(
@@ -465,7 +424,6 @@ def test_method_mark_as_seen(self, client: Knock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_as_seen(self, client: Knock) -> None:
         response = client.messages.with_raw_response.mark_as_seen(
@@ -477,7 +435,6 @@ def test_raw_response_mark_as_seen(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_as_seen(self, client: Knock) -> None:
         with client.messages.with_streaming_response.mark_as_seen(
@@ -491,7 +448,6 @@ def test_streaming_response_mark_as_seen(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_mark_as_seen(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -499,7 +455,6 @@ def test_path_params_mark_as_seen(self, client: Knock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_as_unread(self, client: Knock) -> None:
         message = client.messages.mark_as_unread(
@@ -507,7 +462,6 @@ def test_method_mark_as_unread(self, client: Knock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_as_unread(self, client: Knock) -> None:
         response = client.messages.with_raw_response.mark_as_unread(
@@ -519,7 +473,6 @@ def test_raw_response_mark_as_unread(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_as_unread(self, client: Knock) -> None:
         with client.messages.with_streaming_response.mark_as_unread(
@@ -533,7 +486,6 @@ def test_streaming_response_mark_as_unread(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_mark_as_unread(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -541,7 +493,6 @@ def test_path_params_mark_as_unread(self, client: Knock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_as_unseen(self, client: Knock) -> None:
         message = client.messages.mark_as_unseen(
@@ -549,7 +500,6 @@ def test_method_mark_as_unseen(self, client: Knock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_as_unseen(self, client: Knock) -> None:
         response = client.messages.with_raw_response.mark_as_unseen(
@@ -561,7 +511,6 @@ def test_raw_response_mark_as_unseen(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_as_unseen(self, client: Knock) -> None:
         with client.messages.with_streaming_response.mark_as_unseen(
@@ -575,7 +524,6 @@ def test_streaming_response_mark_as_unseen(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_mark_as_unseen(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -583,7 +531,6 @@ def test_path_params_mark_as_unseen(self, client: Knock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_unarchive(self, client: Knock) -> None:
         message = client.messages.unarchive(
@@ -591,7 +538,6 @@ def test_method_unarchive(self, client: Knock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_unarchive(self, client: Knock) -> None:
         response = client.messages.with_raw_response.unarchive(
@@ -603,7 +549,6 @@ def test_raw_response_unarchive(self, client: Knock) -> None:
         message = response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_unarchive(self, client: Knock) -> None:
         with client.messages.with_streaming_response.unarchive(
@@ -617,7 +562,6 @@ def test_streaming_response_unarchive(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_unarchive(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -631,13 +575,11 @@ class TestAsyncMessages:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.list()
         assert_matches_type(AsyncItemsCursor[Message], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.list(
@@ -663,7 +605,6 @@ async def test_method_list_with_all_params(self, async_client: AsyncKnock) -> No
         )
         assert_matches_type(AsyncItemsCursor[Message], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.list()
@@ -673,7 +614,6 @@ async def test_raw_response_list(self, async_client: AsyncKnock) -> None:
         message = await response.parse()
         assert_matches_type(AsyncItemsCursor[Message], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.list() as response:
@@ -685,7 +625,6 @@ async def test_streaming_response_list(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_archive(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.archive(
@@ -693,7 +632,6 @@ async def test_method_archive(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_archive(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.archive(
@@ -705,7 +643,6 @@ async def test_raw_response_archive(self, async_client: AsyncKnock) -> None:
         message = await response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_archive(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.archive(
@@ -719,7 +656,6 @@ async def test_streaming_response_archive(self, async_client: AsyncKnock) -> Non
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_archive(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -727,7 +663,6 @@ async def test_path_params_archive(self, async_client: AsyncKnock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.get(
@@ -735,7 +670,6 @@ async def test_method_get(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_get(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.get(
@@ -747,7 +681,6 @@ async def test_raw_response_get(self, async_client: AsyncKnock) -> None:
         message = await response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_get(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.get(
@@ -761,7 +694,6 @@ async def test_streaming_response_get(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_get(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -769,7 +701,6 @@ async def test_path_params_get(self, async_client: AsyncKnock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get_content(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.get_content(
@@ -777,7 +708,6 @@ async def test_method_get_content(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(MessageGetContentResponse, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_get_content(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.get_content(
@@ -789,7 +719,6 @@ async def test_raw_response_get_content(self, async_client: AsyncKnock) -> None:
         message = await response.parse()
         assert_matches_type(MessageGetContentResponse, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_get_content(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.get_content(
@@ -803,7 +732,6 @@ async def test_streaming_response_get_content(self, async_client: AsyncKnock) ->
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_get_content(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -811,7 +739,6 @@ async def test_path_params_get_content(self, async_client: AsyncKnock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_activities(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.list_activities(
@@ -819,7 +746,6 @@ async def test_method_list_activities(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(AsyncItemsCursor[Activity], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_activities_with_all_params(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.list_activities(
@@ -831,7 +757,6 @@ async def test_method_list_activities_with_all_params(self, async_client: AsyncK
         )
         assert_matches_type(AsyncItemsCursor[Activity], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_activities(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.list_activities(
@@ -843,7 +768,6 @@ async def test_raw_response_list_activities(self, async_client: AsyncKnock) -> N
         message = await response.parse()
         assert_matches_type(AsyncItemsCursor[Activity], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_activities(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.list_activities(
@@ -857,7 +781,6 @@ async def test_streaming_response_list_activities(self, async_client: AsyncKnock
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_activities(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -865,7 +788,6 @@ async def test_path_params_list_activities(self, async_client: AsyncKnock) -> No
                 message_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_delivery_logs(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.list_delivery_logs(
@@ -873,7 +795,6 @@ async def test_method_list_delivery_logs(self, async_client: AsyncKnock) -> None
         )
         assert_matches_type(AsyncItemsCursor[MessageDeliveryLog], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_delivery_logs_with_all_params(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.list_delivery_logs(
@@ -884,7 +805,6 @@ async def test_method_list_delivery_logs_with_all_params(self, async_client: Asy
         )
         assert_matches_type(AsyncItemsCursor[MessageDeliveryLog], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_delivery_logs(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.list_delivery_logs(
@@ -896,7 +816,6 @@ async def test_raw_response_list_delivery_logs(self, async_client: AsyncKnock) -
         message = await response.parse()
         assert_matches_type(AsyncItemsCursor[MessageDeliveryLog], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_delivery_logs(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.list_delivery_logs(
@@ -910,7 +829,6 @@ async def test_streaming_response_list_delivery_logs(self, async_client: AsyncKn
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_delivery_logs(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -918,7 +836,6 @@ async def test_path_params_list_delivery_logs(self, async_client: AsyncKnock) ->
                 message_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_events(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.list_events(
@@ -926,7 +843,6 @@ async def test_method_list_events(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(AsyncItemsCursor[MessageEvent], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_events_with_all_params(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.list_events(
@@ -937,7 +853,6 @@ async def test_method_list_events_with_all_params(self, async_client: AsyncKnock
         )
         assert_matches_type(AsyncItemsCursor[MessageEvent], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_events(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.list_events(
@@ -949,7 +864,6 @@ async def test_raw_response_list_events(self, async_client: AsyncKnock) -> None:
         message = await response.parse()
         assert_matches_type(AsyncItemsCursor[MessageEvent], message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_events(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.list_events(
@@ -963,7 +877,6 @@ async def test_streaming_response_list_events(self, async_client: AsyncKnock) ->
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_events(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -971,7 +884,6 @@ async def test_path_params_list_events(self, async_client: AsyncKnock) -> None:
                 message_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_as_interacted(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.mark_as_interacted(
@@ -979,7 +891,6 @@ async def test_method_mark_as_interacted(self, async_client: AsyncKnock) -> None
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_as_interacted_with_all_params(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.mark_as_interacted(
@@ -988,7 +899,6 @@ async def test_method_mark_as_interacted_with_all_params(self, async_client: Asy
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_as_interacted(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.mark_as_interacted(
@@ -1000,7 +910,6 @@ async def test_raw_response_mark_as_interacted(self, async_client: AsyncKnock) -
         message = await response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_as_interacted(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.mark_as_interacted(
@@ -1014,7 +923,6 @@ async def test_streaming_response_mark_as_interacted(self, async_client: AsyncKn
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_mark_as_interacted(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -1022,7 +930,6 @@ async def test_path_params_mark_as_interacted(self, async_client: AsyncKnock) ->
                 message_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_as_read(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.mark_as_read(
@@ -1030,7 +937,6 @@ async def test_method_mark_as_read(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_as_read(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.mark_as_read(
@@ -1042,7 +948,6 @@ async def test_raw_response_mark_as_read(self, async_client: AsyncKnock) -> None
         message = await response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_as_read(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.mark_as_read(
@@ -1056,7 +961,6 @@ async def test_streaming_response_mark_as_read(self, async_client: AsyncKnock) -
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_mark_as_read(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -1064,7 +968,6 @@ async def test_path_params_mark_as_read(self, async_client: AsyncKnock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_as_seen(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.mark_as_seen(
@@ -1072,7 +975,6 @@ async def test_method_mark_as_seen(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_as_seen(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.mark_as_seen(
@@ -1084,7 +986,6 @@ async def test_raw_response_mark_as_seen(self, async_client: AsyncKnock) -> None
         message = await response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_as_seen(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.mark_as_seen(
@@ -1098,7 +999,6 @@ async def test_streaming_response_mark_as_seen(self, async_client: AsyncKnock) -
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_mark_as_seen(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -1106,7 +1006,6 @@ async def test_path_params_mark_as_seen(self, async_client: AsyncKnock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_as_unread(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.mark_as_unread(
@@ -1114,7 +1013,6 @@ async def test_method_mark_as_unread(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_as_unread(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.mark_as_unread(
@@ -1126,7 +1024,6 @@ async def test_raw_response_mark_as_unread(self, async_client: AsyncKnock) -> No
         message = await response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_as_unread(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.mark_as_unread(
@@ -1140,7 +1037,6 @@ async def test_streaming_response_mark_as_unread(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_mark_as_unread(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -1148,7 +1044,6 @@ async def test_path_params_mark_as_unread(self, async_client: AsyncKnock) -> Non
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_as_unseen(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.mark_as_unseen(
@@ -1156,7 +1051,6 @@ async def test_method_mark_as_unseen(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_as_unseen(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.mark_as_unseen(
@@ -1168,7 +1062,6 @@ async def test_raw_response_mark_as_unseen(self, async_client: AsyncKnock) -> No
         message = await response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_as_unseen(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.mark_as_unseen(
@@ -1182,7 +1075,6 @@ async def test_streaming_response_mark_as_unseen(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_mark_as_unseen(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
@@ -1190,7 +1082,6 @@ async def test_path_params_mark_as_unseen(self, async_client: AsyncKnock) -> Non
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_unarchive(self, async_client: AsyncKnock) -> None:
         message = await async_client.messages.unarchive(
@@ -1198,7 +1089,6 @@ async def test_method_unarchive(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_unarchive(self, async_client: AsyncKnock) -> None:
         response = await async_client.messages.with_raw_response.unarchive(
@@ -1210,7 +1100,6 @@ async def test_raw_response_unarchive(self, async_client: AsyncKnock) -> None:
         message = await response.parse()
         assert_matches_type(Message, message, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_unarchive(self, async_client: AsyncKnock) -> None:
         async with async_client.messages.with_streaming_response.unarchive(
@@ -1224,7 +1113,6 @@ async def test_streaming_response_unarchive(self, async_client: AsyncKnock) -> N
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_unarchive(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `message_id` but received ''"):
diff --git a/tests/api_resources/test_objects.py b/tests/api_resources/test_objects.py
index b1187ab3..9903f7b0 100644
--- a/tests/api_resources/test_objects.py
+++ b/tests/api_resources/test_objects.py
@@ -30,7 +30,6 @@
 class TestObjects:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list(self, client: Knock) -> None:
         object_ = client.objects.list(
@@ -38,7 +37,6 @@ def test_method_list(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Object], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_with_all_params(self, client: Knock) -> None:
         object_ = client.objects.list(
@@ -50,7 +48,6 @@ def test_method_list_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Object], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list(self, client: Knock) -> None:
         response = client.objects.with_raw_response.list(
@@ -62,7 +59,6 @@ def test_raw_response_list(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(SyncEntriesCursor[Object], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list(self, client: Knock) -> None:
         with client.objects.with_streaming_response.list(
@@ -76,7 +72,6 @@ def test_streaming_response_list(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -84,7 +79,6 @@ def test_path_params_list(self, client: Knock) -> None:
                 collection="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_delete(self, client: Knock) -> None:
         object_ = client.objects.delete(
@@ -93,7 +87,6 @@ def test_method_delete(self, client: Knock) -> None:
         )
         assert object_ is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_delete(self, client: Knock) -> None:
         response = client.objects.with_raw_response.delete(
@@ -106,7 +99,6 @@ def test_raw_response_delete(self, client: Knock) -> None:
         object_ = response.parse()
         assert object_ is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_delete(self, client: Knock) -> None:
         with client.objects.with_streaming_response.delete(
@@ -121,7 +113,6 @@ def test_streaming_response_delete(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_delete(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -136,7 +127,6 @@ def test_path_params_delete(self, client: Knock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_add_subscriptions(self, client: Knock) -> None:
         object_ = client.objects.add_subscriptions(
@@ -146,7 +136,6 @@ def test_method_add_subscriptions(self, client: Knock) -> None:
         )
         assert_matches_type(ObjectAddSubscriptionsResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_add_subscriptions_with_all_params(self, client: Knock) -> None:
         object_ = client.objects.add_subscriptions(
@@ -157,7 +146,6 @@ def test_method_add_subscriptions_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(ObjectAddSubscriptionsResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_add_subscriptions(self, client: Knock) -> None:
         response = client.objects.with_raw_response.add_subscriptions(
@@ -171,7 +159,6 @@ def test_raw_response_add_subscriptions(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(ObjectAddSubscriptionsResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_add_subscriptions(self, client: Knock) -> None:
         with client.objects.with_streaming_response.add_subscriptions(
@@ -187,7 +174,6 @@ def test_streaming_response_add_subscriptions(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_add_subscriptions(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -204,7 +190,6 @@ def test_path_params_add_subscriptions(self, client: Knock) -> None:
                 recipients=["user_1", "user_2"],
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_delete_subscriptions(self, client: Knock) -> None:
         object_ = client.objects.delete_subscriptions(
@@ -214,7 +199,6 @@ def test_method_delete_subscriptions(self, client: Knock) -> None:
         )
         assert_matches_type(ObjectDeleteSubscriptionsResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_delete_subscriptions(self, client: Knock) -> None:
         response = client.objects.with_raw_response.delete_subscriptions(
@@ -228,7 +212,6 @@ def test_raw_response_delete_subscriptions(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(ObjectDeleteSubscriptionsResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_delete_subscriptions(self, client: Knock) -> None:
         with client.objects.with_streaming_response.delete_subscriptions(
@@ -244,7 +227,6 @@ def test_streaming_response_delete_subscriptions(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_delete_subscriptions(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -261,7 +243,6 @@ def test_path_params_delete_subscriptions(self, client: Knock) -> None:
                 recipients=["user_123"],
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get(self, client: Knock) -> None:
         object_ = client.objects.get(
@@ -270,7 +251,6 @@ def test_method_get(self, client: Knock) -> None:
         )
         assert_matches_type(Object, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_get(self, client: Knock) -> None:
         response = client.objects.with_raw_response.get(
@@ -283,7 +263,6 @@ def test_raw_response_get(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(Object, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_get(self, client: Knock) -> None:
         with client.objects.with_streaming_response.get(
@@ -298,7 +277,6 @@ def test_streaming_response_get(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_get(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -313,7 +291,6 @@ def test_path_params_get(self, client: Knock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get_channel_data(self, client: Knock) -> None:
         object_ = client.objects.get_channel_data(
@@ -323,7 +300,6 @@ def test_method_get_channel_data(self, client: Knock) -> None:
         )
         assert_matches_type(ChannelData, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_get_channel_data(self, client: Knock) -> None:
         response = client.objects.with_raw_response.get_channel_data(
@@ -337,7 +313,6 @@ def test_raw_response_get_channel_data(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(ChannelData, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_get_channel_data(self, client: Knock) -> None:
         with client.objects.with_streaming_response.get_channel_data(
@@ -353,7 +328,6 @@ def test_streaming_response_get_channel_data(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_get_channel_data(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -377,7 +351,6 @@ def test_path_params_get_channel_data(self, client: Knock) -> None:
                 channel_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get_preferences(self, client: Knock) -> None:
         object_ = client.objects.get_preferences(
@@ -387,7 +360,6 @@ def test_method_get_preferences(self, client: Knock) -> None:
         )
         assert_matches_type(PreferenceSet, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_get_preferences(self, client: Knock) -> None:
         response = client.objects.with_raw_response.get_preferences(
@@ -401,7 +373,6 @@ def test_raw_response_get_preferences(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(PreferenceSet, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_get_preferences(self, client: Knock) -> None:
         with client.objects.with_streaming_response.get_preferences(
@@ -417,7 +388,6 @@ def test_streaming_response_get_preferences(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_get_preferences(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -441,7 +411,6 @@ def test_path_params_get_preferences(self, client: Knock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_messages(self, client: Knock) -> None:
         object_ = client.objects.list_messages(
@@ -450,7 +419,6 @@ def test_method_list_messages(self, client: Knock) -> None:
         )
         assert_matches_type(SyncItemsCursor[Message], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_messages_with_all_params(self, client: Knock) -> None:
         object_ = client.objects.list_messages(
@@ -478,7 +446,6 @@ def test_method_list_messages_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncItemsCursor[Message], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_messages(self, client: Knock) -> None:
         response = client.objects.with_raw_response.list_messages(
@@ -491,7 +458,6 @@ def test_raw_response_list_messages(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(SyncItemsCursor[Message], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_messages(self, client: Knock) -> None:
         with client.objects.with_streaming_response.list_messages(
@@ -506,7 +472,6 @@ def test_streaming_response_list_messages(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_messages(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -521,7 +486,6 @@ def test_path_params_list_messages(self, client: Knock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_preferences(self, client: Knock) -> None:
         object_ = client.objects.list_preferences(
@@ -530,7 +494,6 @@ def test_method_list_preferences(self, client: Knock) -> None:
         )
         assert_matches_type(ObjectListPreferencesResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_preferences(self, client: Knock) -> None:
         response = client.objects.with_raw_response.list_preferences(
@@ -543,7 +506,6 @@ def test_raw_response_list_preferences(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(ObjectListPreferencesResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_preferences(self, client: Knock) -> None:
         with client.objects.with_streaming_response.list_preferences(
@@ -558,7 +520,6 @@ def test_streaming_response_list_preferences(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_preferences(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -573,7 +534,6 @@ def test_path_params_list_preferences(self, client: Knock) -> None:
                 object_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_schedules(self, client: Knock) -> None:
         object_ = client.objects.list_schedules(
@@ -582,7 +542,6 @@ def test_method_list_schedules(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Schedule], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_schedules_with_all_params(self, client: Knock) -> None:
         object_ = client.objects.list_schedules(
@@ -596,7 +555,6 @@ def test_method_list_schedules_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Schedule], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_schedules(self, client: Knock) -> None:
         response = client.objects.with_raw_response.list_schedules(
@@ -609,7 +567,6 @@ def test_raw_response_list_schedules(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(SyncEntriesCursor[Schedule], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_schedules(self, client: Knock) -> None:
         with client.objects.with_streaming_response.list_schedules(
@@ -624,7 +581,6 @@ def test_streaming_response_list_schedules(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_schedules(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -639,7 +595,6 @@ def test_path_params_list_schedules(self, client: Knock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_subscriptions(self, client: Knock) -> None:
         object_ = client.objects.list_subscriptions(
@@ -648,7 +603,6 @@ def test_method_list_subscriptions(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Subscription], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_subscriptions_with_all_params(self, client: Knock) -> None:
         object_ = client.objects.list_subscriptions(
@@ -669,7 +623,6 @@ def test_method_list_subscriptions_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Subscription], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_subscriptions(self, client: Knock) -> None:
         response = client.objects.with_raw_response.list_subscriptions(
@@ -682,7 +635,6 @@ def test_raw_response_list_subscriptions(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(SyncEntriesCursor[Subscription], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_subscriptions(self, client: Knock) -> None:
         with client.objects.with_streaming_response.list_subscriptions(
@@ -697,7 +649,6 @@ def test_streaming_response_list_subscriptions(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_subscriptions(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -712,7 +663,6 @@ def test_path_params_list_subscriptions(self, client: Knock) -> None:
                 object_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set(self, client: Knock) -> None:
         object_ = client.objects.set(
@@ -721,7 +671,6 @@ def test_method_set(self, client: Knock) -> None:
         )
         assert_matches_type(Object, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set_with_all_params(self, client: Knock) -> None:
         object_ = client.objects.set(
@@ -737,11 +686,43 @@ def test_method_set_with_all_params(self, client: Knock) -> None:
                         "marketing": False,
                         "transactional": {
                             "channel_types": {
-                                "chat": True,
+                                "chat": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "email": False,
-                                "http": True,
-                                "in_app_feed": True,
-                                "push": True,
+                                "http": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "in_app_feed": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "push": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "sms": {
                                     "conditions": [
                                         {
@@ -763,11 +744,43 @@ def test_method_set_with_all_params(self, client: Knock) -> None:
                         },
                     },
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": True,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -794,11 +807,43 @@ def test_method_set_with_all_params(self, client: Knock) -> None:
                     "workflows": {
                         "dinosaurs-loose": {
                             "channel_types": {
-                                "chat": True,
+                                "chat": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "email": True,
-                                "http": True,
-                                "in_app_feed": True,
-                                "push": True,
+                                "http": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "in_app_feed": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "push": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "sms": {
                                     "conditions": [
                                         {
@@ -825,7 +870,6 @@ def test_method_set_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(Object, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_set(self, client: Knock) -> None:
         response = client.objects.with_raw_response.set(
@@ -838,7 +882,6 @@ def test_raw_response_set(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(Object, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_set(self, client: Knock) -> None:
         with client.objects.with_streaming_response.set(
@@ -853,7 +896,6 @@ def test_streaming_response_set(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_set(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -868,7 +910,6 @@ def test_path_params_set(self, client: Knock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set_channel_data(self, client: Knock) -> None:
         object_ = client.objects.set_channel_data(
@@ -879,7 +920,6 @@ def test_method_set_channel_data(self, client: Knock) -> None:
         )
         assert_matches_type(ChannelData, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set_channel_data_with_all_params(self, client: Knock) -> None:
         object_ = client.objects.set_channel_data(
@@ -890,7 +930,6 @@ def test_method_set_channel_data_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(ChannelData, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_set_channel_data(self, client: Knock) -> None:
         response = client.objects.with_raw_response.set_channel_data(
@@ -905,7 +944,6 @@ def test_raw_response_set_channel_data(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(ChannelData, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_set_channel_data(self, client: Knock) -> None:
         with client.objects.with_streaming_response.set_channel_data(
@@ -922,7 +960,6 @@ def test_streaming_response_set_channel_data(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_set_channel_data(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -949,7 +986,6 @@ def test_path_params_set_channel_data(self, client: Knock) -> None:
                 data={"tokens": ["push_token_1"]},
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set_preferences(self, client: Knock) -> None:
         object_ = client.objects.set_preferences(
@@ -959,7 +995,6 @@ def test_method_set_preferences(self, client: Knock) -> None:
         )
         assert_matches_type(PreferenceSet, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
         object_ = client.objects.set_preferences(
@@ -971,11 +1006,43 @@ def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
                 "marketing": False,
                 "transactional": {
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": False,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -997,11 +1064,43 @@ def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
                 },
             },
             channel_types={
-                "chat": True,
+                "chat": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
                 "email": True,
-                "http": True,
-                "in_app_feed": True,
-                "push": True,
+                "http": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
+                "in_app_feed": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
+                "push": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
                 "sms": {
                     "conditions": [
                         {
@@ -1028,11 +1127,43 @@ def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
             workflows={
                 "dinosaurs-loose": {
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": False,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -1056,7 +1187,6 @@ def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(PreferenceSet, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_set_preferences(self, client: Knock) -> None:
         response = client.objects.with_raw_response.set_preferences(
@@ -1070,7 +1200,6 @@ def test_raw_response_set_preferences(self, client: Knock) -> None:
         object_ = response.parse()
         assert_matches_type(PreferenceSet, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_set_preferences(self, client: Knock) -> None:
         with client.objects.with_streaming_response.set_preferences(
@@ -1086,7 +1215,6 @@ def test_streaming_response_set_preferences(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_set_preferences(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1110,7 +1238,6 @@ def test_path_params_set_preferences(self, client: Knock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_unset_channel_data(self, client: Knock) -> None:
         object_ = client.objects.unset_channel_data(
@@ -1120,7 +1247,6 @@ def test_method_unset_channel_data(self, client: Knock) -> None:
         )
         assert object_ is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_unset_channel_data(self, client: Knock) -> None:
         response = client.objects.with_raw_response.unset_channel_data(
@@ -1134,7 +1260,6 @@ def test_raw_response_unset_channel_data(self, client: Knock) -> None:
         object_ = response.parse()
         assert object_ is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_unset_channel_data(self, client: Knock) -> None:
         with client.objects.with_streaming_response.unset_channel_data(
@@ -1150,7 +1275,6 @@ def test_streaming_response_unset_channel_data(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_unset_channel_data(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1174,13 +1298,72 @@ def test_path_params_unset_channel_data(self, client: Knock) -> None:
                 channel_id="",
             )
 
+    @parametrize
+    def test_method_unset_preferences(self, client: Knock) -> None:
+        object_ = client.objects.unset_preferences(
+            collection="collection",
+            object_id="object_id",
+            id="default",
+        )
+        assert object_ is None
+
+    @parametrize
+    def test_raw_response_unset_preferences(self, client: Knock) -> None:
+        response = client.objects.with_raw_response.unset_preferences(
+            collection="collection",
+            object_id="object_id",
+            id="default",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        object_ = response.parse()
+        assert object_ is None
+
+    @parametrize
+    def test_streaming_response_unset_preferences(self, client: Knock) -> None:
+        with client.objects.with_streaming_response.unset_preferences(
+            collection="collection",
+            object_id="object_id",
+            id="default",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            object_ = response.parse()
+            assert object_ is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_unset_preferences(self, client: Knock) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
+            client.objects.with_raw_response.unset_preferences(
+                collection="",
+                object_id="object_id",
+                id="default",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `object_id` but received ''"):
+            client.objects.with_raw_response.unset_preferences(
+                collection="collection",
+                object_id="",
+                id="default",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
+            client.objects.with_raw_response.unset_preferences(
+                collection="collection",
+                object_id="object_id",
+                id="",
+            )
+
 
 class TestAsyncObjects:
     parametrize = pytest.mark.parametrize(
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.list(
@@ -1188,7 +1371,6 @@ async def test_method_list(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(AsyncEntriesCursor[Object], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.list(
@@ -1200,7 +1382,6 @@ async def test_method_list_with_all_params(self, async_client: AsyncKnock) -> No
         )
         assert_matches_type(AsyncEntriesCursor[Object], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.list(
@@ -1212,7 +1393,6 @@ async def test_raw_response_list(self, async_client: AsyncKnock) -> None:
         object_ = await response.parse()
         assert_matches_type(AsyncEntriesCursor[Object], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.list(
@@ -1226,7 +1406,6 @@ async def test_streaming_response_list(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1234,7 +1413,6 @@ async def test_path_params_list(self, async_client: AsyncKnock) -> None:
                 collection="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_delete(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.delete(
@@ -1243,7 +1421,6 @@ async def test_method_delete(self, async_client: AsyncKnock) -> None:
         )
         assert object_ is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.delete(
@@ -1256,7 +1433,6 @@ async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         object_ = await response.parse()
         assert object_ is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.delete(
@@ -1271,7 +1447,6 @@ async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1286,7 +1461,6 @@ async def test_path_params_delete(self, async_client: AsyncKnock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_add_subscriptions(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.add_subscriptions(
@@ -1296,7 +1470,6 @@ async def test_method_add_subscriptions(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(ObjectAddSubscriptionsResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_add_subscriptions_with_all_params(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.add_subscriptions(
@@ -1307,7 +1480,6 @@ async def test_method_add_subscriptions_with_all_params(self, async_client: Asyn
         )
         assert_matches_type(ObjectAddSubscriptionsResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_add_subscriptions(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.add_subscriptions(
@@ -1321,7 +1493,6 @@ async def test_raw_response_add_subscriptions(self, async_client: AsyncKnock) ->
         object_ = await response.parse()
         assert_matches_type(ObjectAddSubscriptionsResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_add_subscriptions(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.add_subscriptions(
@@ -1337,7 +1508,6 @@ async def test_streaming_response_add_subscriptions(self, async_client: AsyncKno
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_add_subscriptions(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1354,7 +1524,6 @@ async def test_path_params_add_subscriptions(self, async_client: AsyncKnock) ->
                 recipients=["user_1", "user_2"],
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_delete_subscriptions(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.delete_subscriptions(
@@ -1364,7 +1533,6 @@ async def test_method_delete_subscriptions(self, async_client: AsyncKnock) -> No
         )
         assert_matches_type(ObjectDeleteSubscriptionsResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_delete_subscriptions(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.delete_subscriptions(
@@ -1378,7 +1546,6 @@ async def test_raw_response_delete_subscriptions(self, async_client: AsyncKnock)
         object_ = await response.parse()
         assert_matches_type(ObjectDeleteSubscriptionsResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_delete_subscriptions(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.delete_subscriptions(
@@ -1394,7 +1561,6 @@ async def test_streaming_response_delete_subscriptions(self, async_client: Async
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_delete_subscriptions(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1411,7 +1577,6 @@ async def test_path_params_delete_subscriptions(self, async_client: AsyncKnock)
                 recipients=["user_123"],
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.get(
@@ -1420,7 +1585,6 @@ async def test_method_get(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(Object, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_get(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.get(
@@ -1433,7 +1597,6 @@ async def test_raw_response_get(self, async_client: AsyncKnock) -> None:
         object_ = await response.parse()
         assert_matches_type(Object, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_get(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.get(
@@ -1448,7 +1611,6 @@ async def test_streaming_response_get(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_get(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1463,7 +1625,6 @@ async def test_path_params_get(self, async_client: AsyncKnock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get_channel_data(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.get_channel_data(
@@ -1473,7 +1634,6 @@ async def test_method_get_channel_data(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(ChannelData, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_get_channel_data(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.get_channel_data(
@@ -1487,7 +1647,6 @@ async def test_raw_response_get_channel_data(self, async_client: AsyncKnock) ->
         object_ = await response.parse()
         assert_matches_type(ChannelData, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_get_channel_data(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.get_channel_data(
@@ -1503,7 +1662,6 @@ async def test_streaming_response_get_channel_data(self, async_client: AsyncKnoc
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_get_channel_data(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1527,7 +1685,6 @@ async def test_path_params_get_channel_data(self, async_client: AsyncKnock) -> N
                 channel_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get_preferences(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.get_preferences(
@@ -1537,7 +1694,6 @@ async def test_method_get_preferences(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(PreferenceSet, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_get_preferences(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.get_preferences(
@@ -1551,7 +1707,6 @@ async def test_raw_response_get_preferences(self, async_client: AsyncKnock) -> N
         object_ = await response.parse()
         assert_matches_type(PreferenceSet, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_get_preferences(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.get_preferences(
@@ -1567,7 +1722,6 @@ async def test_streaming_response_get_preferences(self, async_client: AsyncKnock
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_get_preferences(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1591,7 +1745,6 @@ async def test_path_params_get_preferences(self, async_client: AsyncKnock) -> No
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_messages(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.list_messages(
@@ -1600,7 +1753,6 @@ async def test_method_list_messages(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(AsyncItemsCursor[Message], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_messages_with_all_params(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.list_messages(
@@ -1628,7 +1780,6 @@ async def test_method_list_messages_with_all_params(self, async_client: AsyncKno
         )
         assert_matches_type(AsyncItemsCursor[Message], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_messages(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.list_messages(
@@ -1641,7 +1792,6 @@ async def test_raw_response_list_messages(self, async_client: AsyncKnock) -> Non
         object_ = await response.parse()
         assert_matches_type(AsyncItemsCursor[Message], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_messages(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.list_messages(
@@ -1656,7 +1806,6 @@ async def test_streaming_response_list_messages(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_messages(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1671,7 +1820,6 @@ async def test_path_params_list_messages(self, async_client: AsyncKnock) -> None
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_preferences(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.list_preferences(
@@ -1680,7 +1828,6 @@ async def test_method_list_preferences(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(ObjectListPreferencesResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_preferences(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.list_preferences(
@@ -1693,7 +1840,6 @@ async def test_raw_response_list_preferences(self, async_client: AsyncKnock) ->
         object_ = await response.parse()
         assert_matches_type(ObjectListPreferencesResponse, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_preferences(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.list_preferences(
@@ -1708,7 +1854,6 @@ async def test_streaming_response_list_preferences(self, async_client: AsyncKnoc
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_preferences(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1723,7 +1868,6 @@ async def test_path_params_list_preferences(self, async_client: AsyncKnock) -> N
                 object_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_schedules(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.list_schedules(
@@ -1732,7 +1876,6 @@ async def test_method_list_schedules(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(AsyncEntriesCursor[Schedule], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_schedules_with_all_params(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.list_schedules(
@@ -1746,7 +1889,6 @@ async def test_method_list_schedules_with_all_params(self, async_client: AsyncKn
         )
         assert_matches_type(AsyncEntriesCursor[Schedule], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_schedules(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.list_schedules(
@@ -1759,7 +1901,6 @@ async def test_raw_response_list_schedules(self, async_client: AsyncKnock) -> No
         object_ = await response.parse()
         assert_matches_type(AsyncEntriesCursor[Schedule], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_schedules(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.list_schedules(
@@ -1774,7 +1915,6 @@ async def test_streaming_response_list_schedules(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_schedules(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1789,7 +1929,6 @@ async def test_path_params_list_schedules(self, async_client: AsyncKnock) -> Non
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_subscriptions(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.list_subscriptions(
@@ -1798,7 +1937,6 @@ async def test_method_list_subscriptions(self, async_client: AsyncKnock) -> None
         )
         assert_matches_type(AsyncEntriesCursor[Subscription], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_subscriptions_with_all_params(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.list_subscriptions(
@@ -1819,7 +1957,6 @@ async def test_method_list_subscriptions_with_all_params(self, async_client: Asy
         )
         assert_matches_type(AsyncEntriesCursor[Subscription], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_subscriptions(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.list_subscriptions(
@@ -1832,7 +1969,6 @@ async def test_raw_response_list_subscriptions(self, async_client: AsyncKnock) -
         object_ = await response.parse()
         assert_matches_type(AsyncEntriesCursor[Subscription], object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_subscriptions(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.list_subscriptions(
@@ -1847,7 +1983,6 @@ async def test_streaming_response_list_subscriptions(self, async_client: AsyncKn
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_subscriptions(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -1862,7 +1997,6 @@ async def test_path_params_list_subscriptions(self, async_client: AsyncKnock) ->
                 object_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.set(
@@ -1871,7 +2005,6 @@ async def test_method_set(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(Object, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set_with_all_params(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.set(
@@ -1887,11 +2020,43 @@ async def test_method_set_with_all_params(self, async_client: AsyncKnock) -> Non
                         "marketing": False,
                         "transactional": {
                             "channel_types": {
-                                "chat": True,
+                                "chat": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "email": False,
-                                "http": True,
-                                "in_app_feed": True,
-                                "push": True,
+                                "http": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "in_app_feed": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "push": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "sms": {
                                     "conditions": [
                                         {
@@ -1913,11 +2078,43 @@ async def test_method_set_with_all_params(self, async_client: AsyncKnock) -> Non
                         },
                     },
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": True,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -1944,11 +2141,43 @@ async def test_method_set_with_all_params(self, async_client: AsyncKnock) -> Non
                     "workflows": {
                         "dinosaurs-loose": {
                             "channel_types": {
-                                "chat": True,
+                                "chat": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "email": True,
-                                "http": True,
-                                "in_app_feed": True,
-                                "push": True,
+                                "http": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "in_app_feed": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "push": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "sms": {
                                     "conditions": [
                                         {
@@ -1975,7 +2204,6 @@ async def test_method_set_with_all_params(self, async_client: AsyncKnock) -> Non
         )
         assert_matches_type(Object, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_set(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.set(
@@ -1988,7 +2216,6 @@ async def test_raw_response_set(self, async_client: AsyncKnock) -> None:
         object_ = await response.parse()
         assert_matches_type(Object, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_set(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.set(
@@ -2003,7 +2230,6 @@ async def test_streaming_response_set(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_set(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -2018,7 +2244,6 @@ async def test_path_params_set(self, async_client: AsyncKnock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set_channel_data(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.set_channel_data(
@@ -2029,7 +2254,6 @@ async def test_method_set_channel_data(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(ChannelData, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set_channel_data_with_all_params(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.set_channel_data(
@@ -2040,7 +2264,6 @@ async def test_method_set_channel_data_with_all_params(self, async_client: Async
         )
         assert_matches_type(ChannelData, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_set_channel_data(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.set_channel_data(
@@ -2055,7 +2278,6 @@ async def test_raw_response_set_channel_data(self, async_client: AsyncKnock) ->
         object_ = await response.parse()
         assert_matches_type(ChannelData, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_set_channel_data(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.set_channel_data(
@@ -2072,7 +2294,6 @@ async def test_streaming_response_set_channel_data(self, async_client: AsyncKnoc
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_set_channel_data(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -2099,7 +2320,6 @@ async def test_path_params_set_channel_data(self, async_client: AsyncKnock) -> N
                 data={"tokens": ["push_token_1"]},
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set_preferences(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.set_preferences(
@@ -2109,7 +2329,6 @@ async def test_method_set_preferences(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(PreferenceSet, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set_preferences_with_all_params(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.set_preferences(
@@ -2121,11 +2340,43 @@ async def test_method_set_preferences_with_all_params(self, async_client: AsyncK
                 "marketing": False,
                 "transactional": {
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": False,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -2147,11 +2398,43 @@ async def test_method_set_preferences_with_all_params(self, async_client: AsyncK
                 },
             },
             channel_types={
-                "chat": True,
+                "chat": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
                 "email": True,
-                "http": True,
-                "in_app_feed": True,
-                "push": True,
+                "http": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
+                "in_app_feed": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
+                "push": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
                 "sms": {
                     "conditions": [
                         {
@@ -2178,11 +2461,43 @@ async def test_method_set_preferences_with_all_params(self, async_client: AsyncK
             workflows={
                 "dinosaurs-loose": {
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": False,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -2206,7 +2521,6 @@ async def test_method_set_preferences_with_all_params(self, async_client: AsyncK
         )
         assert_matches_type(PreferenceSet, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_set_preferences(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.set_preferences(
@@ -2220,7 +2534,6 @@ async def test_raw_response_set_preferences(self, async_client: AsyncKnock) -> N
         object_ = await response.parse()
         assert_matches_type(PreferenceSet, object_, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_set_preferences(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.set_preferences(
@@ -2236,7 +2549,6 @@ async def test_streaming_response_set_preferences(self, async_client: AsyncKnock
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_set_preferences(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -2260,7 +2572,6 @@ async def test_path_params_set_preferences(self, async_client: AsyncKnock) -> No
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_unset_channel_data(self, async_client: AsyncKnock) -> None:
         object_ = await async_client.objects.unset_channel_data(
@@ -2270,7 +2581,6 @@ async def test_method_unset_channel_data(self, async_client: AsyncKnock) -> None
         )
         assert object_ is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_unset_channel_data(self, async_client: AsyncKnock) -> None:
         response = await async_client.objects.with_raw_response.unset_channel_data(
@@ -2284,7 +2594,6 @@ async def test_raw_response_unset_channel_data(self, async_client: AsyncKnock) -
         object_ = await response.parse()
         assert object_ is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_unset_channel_data(self, async_client: AsyncKnock) -> None:
         async with async_client.objects.with_streaming_response.unset_channel_data(
@@ -2300,7 +2609,6 @@ async def test_streaming_response_unset_channel_data(self, async_client: AsyncKn
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_unset_channel_data(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
@@ -2323,3 +2631,63 @@ async def test_path_params_unset_channel_data(self, async_client: AsyncKnock) ->
                 object_id="object_id",
                 channel_id="",
             )
+
+    @parametrize
+    async def test_method_unset_preferences(self, async_client: AsyncKnock) -> None:
+        object_ = await async_client.objects.unset_preferences(
+            collection="collection",
+            object_id="object_id",
+            id="default",
+        )
+        assert object_ is None
+
+    @parametrize
+    async def test_raw_response_unset_preferences(self, async_client: AsyncKnock) -> None:
+        response = await async_client.objects.with_raw_response.unset_preferences(
+            collection="collection",
+            object_id="object_id",
+            id="default",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        object_ = await response.parse()
+        assert object_ is None
+
+    @parametrize
+    async def test_streaming_response_unset_preferences(self, async_client: AsyncKnock) -> None:
+        async with async_client.objects.with_streaming_response.unset_preferences(
+            collection="collection",
+            object_id="object_id",
+            id="default",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            object_ = await response.parse()
+            assert object_ is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_unset_preferences(self, async_client: AsyncKnock) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `collection` but received ''"):
+            await async_client.objects.with_raw_response.unset_preferences(
+                collection="",
+                object_id="object_id",
+                id="default",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `object_id` but received ''"):
+            await async_client.objects.with_raw_response.unset_preferences(
+                collection="collection",
+                object_id="",
+                id="default",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
+            await async_client.objects.with_raw_response.unset_preferences(
+                collection="collection",
+                object_id="object_id",
+                id="",
+            )
diff --git a/tests/api_resources/test_schedules.py b/tests/api_resources/test_schedules.py
index 743d9f74..3ff634a2 100644
--- a/tests/api_resources/test_schedules.py
+++ b/tests/api_resources/test_schedules.py
@@ -24,7 +24,6 @@
 class TestSchedules:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_create(self, client: Knock) -> None:
         schedule = client.schedules.create(
@@ -33,7 +32,6 @@ def test_method_create(self, client: Knock) -> None:
         )
         assert_matches_type(ScheduleCreateResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_create_with_all_params(self, client: Knock) -> None:
         schedule = client.schedules.create(
@@ -55,11 +53,43 @@ def test_method_create_with_all_params(self, client: Knock) -> None:
                             "marketing": False,
                             "transactional": {
                                 "channel_types": {
-                                    "chat": True,
+                                    "chat": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
                                     "email": False,
-                                    "http": True,
-                                    "in_app_feed": True,
-                                    "push": True,
+                                    "http": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
+                                    "in_app_feed": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
+                                    "push": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
                                     "sms": {
                                         "conditions": [
                                             {
@@ -81,11 +111,43 @@ def test_method_create_with_all_params(self, client: Knock) -> None:
                             },
                         },
                         "channel_types": {
-                            "chat": True,
+                            "chat": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
                             "email": True,
-                            "http": True,
-                            "in_app_feed": True,
-                            "push": True,
+                            "http": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
+                            "in_app_feed": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
+                            "push": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
                             "sms": {
                                 "conditions": [
                                     {
@@ -112,11 +174,43 @@ def test_method_create_with_all_params(self, client: Knock) -> None:
                         "workflows": {
                             "dinosaurs-loose": {
                                 "channel_types": {
-                                    "chat": True,
+                                    "chat": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
                                     "email": True,
-                                    "http": True,
-                                    "in_app_feed": True,
-                                    "push": True,
+                                    "http": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
+                                    "in_app_feed": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
+                                    "push": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
                                     "sms": {
                                         "conditions": [
                                             {
@@ -159,7 +253,6 @@ def test_method_create_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(ScheduleCreateResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_create(self, client: Knock) -> None:
         response = client.schedules.with_raw_response.create(
@@ -172,7 +265,6 @@ def test_raw_response_create(self, client: Knock) -> None:
         schedule = response.parse()
         assert_matches_type(ScheduleCreateResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_create(self, client: Knock) -> None:
         with client.schedules.with_streaming_response.create(
@@ -187,7 +279,6 @@ def test_streaming_response_create(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_update(self, client: Knock) -> None:
         schedule = client.schedules.update(
@@ -195,7 +286,6 @@ def test_method_update(self, client: Knock) -> None:
         )
         assert_matches_type(ScheduleUpdateResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_update_with_all_params(self, client: Knock) -> None:
         schedule = client.schedules.update(
@@ -219,7 +309,6 @@ def test_method_update_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(ScheduleUpdateResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_update(self, client: Knock) -> None:
         response = client.schedules.with_raw_response.update(
@@ -231,7 +320,6 @@ def test_raw_response_update(self, client: Knock) -> None:
         schedule = response.parse()
         assert_matches_type(ScheduleUpdateResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_update(self, client: Knock) -> None:
         with client.schedules.with_streaming_response.update(
@@ -245,7 +333,6 @@ def test_streaming_response_update(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list(self, client: Knock) -> None:
         schedule = client.schedules.list(
@@ -253,7 +340,6 @@ def test_method_list(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Schedule], schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_with_all_params(self, client: Knock) -> None:
         schedule = client.schedules.list(
@@ -266,7 +352,6 @@ def test_method_list_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Schedule], schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list(self, client: Knock) -> None:
         response = client.schedules.with_raw_response.list(
@@ -278,7 +363,6 @@ def test_raw_response_list(self, client: Knock) -> None:
         schedule = response.parse()
         assert_matches_type(SyncEntriesCursor[Schedule], schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list(self, client: Knock) -> None:
         with client.schedules.with_streaming_response.list(
@@ -292,7 +376,6 @@ def test_streaming_response_list(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_delete(self, client: Knock) -> None:
         schedule = client.schedules.delete(
@@ -300,7 +383,6 @@ def test_method_delete(self, client: Knock) -> None:
         )
         assert_matches_type(ScheduleDeleteResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_delete(self, client: Knock) -> None:
         response = client.schedules.with_raw_response.delete(
@@ -312,7 +394,6 @@ def test_raw_response_delete(self, client: Knock) -> None:
         schedule = response.parse()
         assert_matches_type(ScheduleDeleteResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_delete(self, client: Knock) -> None:
         with client.schedules.with_streaming_response.delete(
@@ -332,7 +413,6 @@ class TestAsyncSchedules:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_create(self, async_client: AsyncKnock) -> None:
         schedule = await async_client.schedules.create(
@@ -341,7 +421,6 @@ async def test_method_create(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(ScheduleCreateResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncKnock) -> None:
         schedule = await async_client.schedules.create(
@@ -363,11 +442,43 @@ async def test_method_create_with_all_params(self, async_client: AsyncKnock) ->
                             "marketing": False,
                             "transactional": {
                                 "channel_types": {
-                                    "chat": True,
+                                    "chat": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
                                     "email": False,
-                                    "http": True,
-                                    "in_app_feed": True,
-                                    "push": True,
+                                    "http": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
+                                    "in_app_feed": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
+                                    "push": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
                                     "sms": {
                                         "conditions": [
                                             {
@@ -389,11 +500,43 @@ async def test_method_create_with_all_params(self, async_client: AsyncKnock) ->
                             },
                         },
                         "channel_types": {
-                            "chat": True,
+                            "chat": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
                             "email": True,
-                            "http": True,
-                            "in_app_feed": True,
-                            "push": True,
+                            "http": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
+                            "in_app_feed": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
+                            "push": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
                             "sms": {
                                 "conditions": [
                                     {
@@ -420,11 +563,43 @@ async def test_method_create_with_all_params(self, async_client: AsyncKnock) ->
                         "workflows": {
                             "dinosaurs-loose": {
                                 "channel_types": {
-                                    "chat": True,
+                                    "chat": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
                                     "email": True,
-                                    "http": True,
-                                    "in_app_feed": True,
-                                    "push": True,
+                                    "http": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
+                                    "in_app_feed": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
+                                    "push": {
+                                        "conditions": [
+                                            {
+                                                "argument": "US",
+                                                "operator": "equal_to",
+                                                "variable": "recipient.country_code",
+                                            }
+                                        ]
+                                    },
                                     "sms": {
                                         "conditions": [
                                             {
@@ -467,7 +642,6 @@ async def test_method_create_with_all_params(self, async_client: AsyncKnock) ->
         )
         assert_matches_type(ScheduleCreateResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncKnock) -> None:
         response = await async_client.schedules.with_raw_response.create(
@@ -480,7 +654,6 @@ async def test_raw_response_create(self, async_client: AsyncKnock) -> None:
         schedule = await response.parse()
         assert_matches_type(ScheduleCreateResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncKnock) -> None:
         async with async_client.schedules.with_streaming_response.create(
@@ -495,7 +668,6 @@ async def test_streaming_response_create(self, async_client: AsyncKnock) -> None
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_update(self, async_client: AsyncKnock) -> None:
         schedule = await async_client.schedules.update(
@@ -503,7 +675,6 @@ async def test_method_update(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(ScheduleUpdateResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_update_with_all_params(self, async_client: AsyncKnock) -> None:
         schedule = await async_client.schedules.update(
@@ -527,7 +698,6 @@ async def test_method_update_with_all_params(self, async_client: AsyncKnock) ->
         )
         assert_matches_type(ScheduleUpdateResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncKnock) -> None:
         response = await async_client.schedules.with_raw_response.update(
@@ -539,7 +709,6 @@ async def test_raw_response_update(self, async_client: AsyncKnock) -> None:
         schedule = await response.parse()
         assert_matches_type(ScheduleUpdateResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncKnock) -> None:
         async with async_client.schedules.with_streaming_response.update(
@@ -553,7 +722,6 @@ async def test_streaming_response_update(self, async_client: AsyncKnock) -> None
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list(self, async_client: AsyncKnock) -> None:
         schedule = await async_client.schedules.list(
@@ -561,7 +729,6 @@ async def test_method_list(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(AsyncEntriesCursor[Schedule], schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncKnock) -> None:
         schedule = await async_client.schedules.list(
@@ -574,7 +741,6 @@ async def test_method_list_with_all_params(self, async_client: AsyncKnock) -> No
         )
         assert_matches_type(AsyncEntriesCursor[Schedule], schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncKnock) -> None:
         response = await async_client.schedules.with_raw_response.list(
@@ -586,7 +752,6 @@ async def test_raw_response_list(self, async_client: AsyncKnock) -> None:
         schedule = await response.parse()
         assert_matches_type(AsyncEntriesCursor[Schedule], schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncKnock) -> None:
         async with async_client.schedules.with_streaming_response.list(
@@ -600,7 +765,6 @@ async def test_streaming_response_list(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_delete(self, async_client: AsyncKnock) -> None:
         schedule = await async_client.schedules.delete(
@@ -608,7 +772,6 @@ async def test_method_delete(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(ScheduleDeleteResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         response = await async_client.schedules.with_raw_response.delete(
@@ -620,7 +783,6 @@ async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         schedule = await response.parse()
         assert_matches_type(ScheduleDeleteResponse, schedule, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None:
         async with async_client.schedules.with_streaming_response.delete(
diff --git a/tests/api_resources/test_tenants.py b/tests/api_resources/test_tenants.py
index 796aa18a..95c518c2 100644
--- a/tests/api_resources/test_tenants.py
+++ b/tests/api_resources/test_tenants.py
@@ -18,13 +18,11 @@
 class TestTenants:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list(self, client: Knock) -> None:
         tenant = client.tenants.list()
         assert_matches_type(SyncEntriesCursor[Tenant], tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_with_all_params(self, client: Knock) -> None:
         tenant = client.tenants.list(
@@ -36,7 +34,6 @@ def test_method_list_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Tenant], tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list(self, client: Knock) -> None:
         response = client.tenants.with_raw_response.list()
@@ -46,7 +43,6 @@ def test_raw_response_list(self, client: Knock) -> None:
         tenant = response.parse()
         assert_matches_type(SyncEntriesCursor[Tenant], tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list(self, client: Knock) -> None:
         with client.tenants.with_streaming_response.list() as response:
@@ -58,7 +54,6 @@ def test_streaming_response_list(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_delete(self, client: Knock) -> None:
         tenant = client.tenants.delete(
@@ -66,7 +61,6 @@ def test_method_delete(self, client: Knock) -> None:
         )
         assert tenant is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_delete(self, client: Knock) -> None:
         response = client.tenants.with_raw_response.delete(
@@ -78,7 +72,6 @@ def test_raw_response_delete(self, client: Knock) -> None:
         tenant = response.parse()
         assert tenant is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_delete(self, client: Knock) -> None:
         with client.tenants.with_streaming_response.delete(
@@ -92,7 +85,6 @@ def test_streaming_response_delete(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_delete(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
@@ -100,7 +92,6 @@ def test_path_params_delete(self, client: Knock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get(self, client: Knock) -> None:
         tenant = client.tenants.get(
@@ -108,7 +99,6 @@ def test_method_get(self, client: Knock) -> None:
         )
         assert_matches_type(Tenant, tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get_with_all_params(self, client: Knock) -> None:
         tenant = client.tenants.get(
@@ -117,7 +107,6 @@ def test_method_get_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(Tenant, tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_get(self, client: Knock) -> None:
         response = client.tenants.with_raw_response.get(
@@ -129,7 +118,6 @@ def test_raw_response_get(self, client: Knock) -> None:
         tenant = response.parse()
         assert_matches_type(Tenant, tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_get(self, client: Knock) -> None:
         with client.tenants.with_streaming_response.get(
@@ -143,7 +131,6 @@ def test_streaming_response_get(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_get(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
@@ -151,7 +138,6 @@ def test_path_params_get(self, client: Knock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set(self, client: Knock) -> None:
         tenant = client.tenants.set(
@@ -159,7 +145,6 @@ def test_method_set(self, client: Knock) -> None:
         )
         assert_matches_type(Tenant, tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set_with_all_params(self, client: Knock) -> None:
         tenant = client.tenants.set(
@@ -180,11 +165,43 @@ def test_method_set_with_all_params(self, client: Knock) -> None:
                         "marketing": False,
                         "transactional": {
                             "channel_types": {
-                                "chat": True,
+                                "chat": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "email": False,
-                                "http": True,
-                                "in_app_feed": True,
-                                "push": True,
+                                "http": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "in_app_feed": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "push": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "sms": {
                                     "conditions": [
                                         {
@@ -206,11 +223,43 @@ def test_method_set_with_all_params(self, client: Knock) -> None:
                         },
                     },
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": True,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -237,11 +286,43 @@ def test_method_set_with_all_params(self, client: Knock) -> None:
                     "workflows": {
                         "dinosaurs-loose": {
                             "channel_types": {
-                                "chat": True,
+                                "chat": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "email": False,
-                                "http": True,
-                                "in_app_feed": True,
-                                "push": True,
+                                "http": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "in_app_feed": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "push": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "sms": {
                                     "conditions": [
                                         {
@@ -267,7 +348,6 @@ def test_method_set_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(Tenant, tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_set(self, client: Knock) -> None:
         response = client.tenants.with_raw_response.set(
@@ -279,7 +359,6 @@ def test_raw_response_set(self, client: Knock) -> None:
         tenant = response.parse()
         assert_matches_type(Tenant, tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_set(self, client: Knock) -> None:
         with client.tenants.with_streaming_response.set(
@@ -293,7 +372,6 @@ def test_streaming_response_set(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_set(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
@@ -307,13 +385,11 @@ class TestAsyncTenants:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list(self, async_client: AsyncKnock) -> None:
         tenant = await async_client.tenants.list()
         assert_matches_type(AsyncEntriesCursor[Tenant], tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncKnock) -> None:
         tenant = await async_client.tenants.list(
@@ -325,7 +401,6 @@ async def test_method_list_with_all_params(self, async_client: AsyncKnock) -> No
         )
         assert_matches_type(AsyncEntriesCursor[Tenant], tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncKnock) -> None:
         response = await async_client.tenants.with_raw_response.list()
@@ -335,7 +410,6 @@ async def test_raw_response_list(self, async_client: AsyncKnock) -> None:
         tenant = await response.parse()
         assert_matches_type(AsyncEntriesCursor[Tenant], tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncKnock) -> None:
         async with async_client.tenants.with_streaming_response.list() as response:
@@ -347,7 +421,6 @@ async def test_streaming_response_list(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_delete(self, async_client: AsyncKnock) -> None:
         tenant = await async_client.tenants.delete(
@@ -355,7 +428,6 @@ async def test_method_delete(self, async_client: AsyncKnock) -> None:
         )
         assert tenant is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         response = await async_client.tenants.with_raw_response.delete(
@@ -367,7 +439,6 @@ async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         tenant = await response.parse()
         assert tenant is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None:
         async with async_client.tenants.with_streaming_response.delete(
@@ -381,7 +452,6 @@ async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
@@ -389,7 +459,6 @@ async def test_path_params_delete(self, async_client: AsyncKnock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get(self, async_client: AsyncKnock) -> None:
         tenant = await async_client.tenants.get(
@@ -397,7 +466,6 @@ async def test_method_get(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(Tenant, tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get_with_all_params(self, async_client: AsyncKnock) -> None:
         tenant = await async_client.tenants.get(
@@ -406,7 +474,6 @@ async def test_method_get_with_all_params(self, async_client: AsyncKnock) -> Non
         )
         assert_matches_type(Tenant, tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_get(self, async_client: AsyncKnock) -> None:
         response = await async_client.tenants.with_raw_response.get(
@@ -418,7 +485,6 @@ async def test_raw_response_get(self, async_client: AsyncKnock) -> None:
         tenant = await response.parse()
         assert_matches_type(Tenant, tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_get(self, async_client: AsyncKnock) -> None:
         async with async_client.tenants.with_streaming_response.get(
@@ -432,7 +498,6 @@ async def test_streaming_response_get(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_get(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
@@ -440,7 +505,6 @@ async def test_path_params_get(self, async_client: AsyncKnock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set(self, async_client: AsyncKnock) -> None:
         tenant = await async_client.tenants.set(
@@ -448,7 +512,6 @@ async def test_method_set(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(Tenant, tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set_with_all_params(self, async_client: AsyncKnock) -> None:
         tenant = await async_client.tenants.set(
@@ -469,11 +532,43 @@ async def test_method_set_with_all_params(self, async_client: AsyncKnock) -> Non
                         "marketing": False,
                         "transactional": {
                             "channel_types": {
-                                "chat": True,
+                                "chat": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "email": False,
-                                "http": True,
-                                "in_app_feed": True,
-                                "push": True,
+                                "http": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "in_app_feed": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "push": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "sms": {
                                     "conditions": [
                                         {
@@ -495,11 +590,43 @@ async def test_method_set_with_all_params(self, async_client: AsyncKnock) -> Non
                         },
                     },
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": True,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -526,11 +653,43 @@ async def test_method_set_with_all_params(self, async_client: AsyncKnock) -> Non
                     "workflows": {
                         "dinosaurs-loose": {
                             "channel_types": {
-                                "chat": True,
+                                "chat": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "email": False,
-                                "http": True,
-                                "in_app_feed": True,
-                                "push": True,
+                                "http": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "in_app_feed": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "push": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "sms": {
                                     "conditions": [
                                         {
@@ -556,7 +715,6 @@ async def test_method_set_with_all_params(self, async_client: AsyncKnock) -> Non
         )
         assert_matches_type(Tenant, tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_set(self, async_client: AsyncKnock) -> None:
         response = await async_client.tenants.with_raw_response.set(
@@ -568,7 +726,6 @@ async def test_raw_response_set(self, async_client: AsyncKnock) -> None:
         tenant = await response.parse()
         assert_matches_type(Tenant, tenant, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_set(self, async_client: AsyncKnock) -> None:
         async with async_client.tenants.with_streaming_response.set(
@@ -582,7 +739,6 @@ async def test_streaming_response_set(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_set(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
diff --git a/tests/api_resources/test_users.py b/tests/api_resources/test_users.py
index 6992c081..48411c6f 100644
--- a/tests/api_resources/test_users.py
+++ b/tests/api_resources/test_users.py
@@ -29,7 +29,6 @@
 class TestUsers:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_update(self, client: Knock) -> None:
         user = client.users.update(
@@ -37,7 +36,6 @@ def test_method_update(self, client: Knock) -> None:
         )
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_update_with_all_params(self, client: Knock) -> None:
         user = client.users.update(
@@ -56,11 +54,43 @@ def test_method_update_with_all_params(self, client: Knock) -> None:
                         "marketing": False,
                         "transactional": {
                             "channel_types": {
-                                "chat": True,
+                                "chat": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "email": False,
-                                "http": True,
-                                "in_app_feed": True,
-                                "push": True,
+                                "http": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "in_app_feed": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "push": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "sms": {
                                     "conditions": [
                                         {
@@ -82,11 +112,43 @@ def test_method_update_with_all_params(self, client: Knock) -> None:
                         },
                     },
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": True,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -113,11 +175,43 @@ def test_method_update_with_all_params(self, client: Knock) -> None:
                     "workflows": {
                         "dinosaurs-loose": {
                             "channel_types": {
-                                "chat": True,
+                                "chat": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "email": True,
-                                "http": True,
-                                "in_app_feed": True,
-                                "push": True,
+                                "http": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "in_app_feed": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "push": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "sms": {
                                     "conditions": [
                                         {
@@ -144,7 +238,6 @@ def test_method_update_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_update(self, client: Knock) -> None:
         response = client.users.with_raw_response.update(
@@ -156,7 +249,6 @@ def test_raw_response_update(self, client: Knock) -> None:
         user = response.parse()
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_update(self, client: Knock) -> None:
         with client.users.with_streaming_response.update(
@@ -170,7 +262,6 @@ def test_streaming_response_update(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_update(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -178,13 +269,11 @@ def test_path_params_update(self, client: Knock) -> None:
                 user_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list(self, client: Knock) -> None:
         user = client.users.list()
         assert_matches_type(SyncEntriesCursor[User], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_with_all_params(self, client: Knock) -> None:
         user = client.users.list(
@@ -195,7 +284,6 @@ def test_method_list_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[User], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list(self, client: Knock) -> None:
         response = client.users.with_raw_response.list()
@@ -205,7 +293,6 @@ def test_raw_response_list(self, client: Knock) -> None:
         user = response.parse()
         assert_matches_type(SyncEntriesCursor[User], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list(self, client: Knock) -> None:
         with client.users.with_streaming_response.list() as response:
@@ -217,7 +304,6 @@ def test_streaming_response_list(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_delete(self, client: Knock) -> None:
         user = client.users.delete(
@@ -225,7 +311,6 @@ def test_method_delete(self, client: Knock) -> None:
         )
         assert user is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_delete(self, client: Knock) -> None:
         response = client.users.with_raw_response.delete(
@@ -237,7 +322,6 @@ def test_raw_response_delete(self, client: Knock) -> None:
         user = response.parse()
         assert user is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_delete(self, client: Knock) -> None:
         with client.users.with_streaming_response.delete(
@@ -251,7 +335,6 @@ def test_streaming_response_delete(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_delete(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -259,7 +342,6 @@ def test_path_params_delete(self, client: Knock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get(self, client: Knock) -> None:
         user = client.users.get(
@@ -267,7 +349,6 @@ def test_method_get(self, client: Knock) -> None:
         )
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_get(self, client: Knock) -> None:
         response = client.users.with_raw_response.get(
@@ -279,7 +360,6 @@ def test_raw_response_get(self, client: Knock) -> None:
         user = response.parse()
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_get(self, client: Knock) -> None:
         with client.users.with_streaming_response.get(
@@ -293,7 +373,6 @@ def test_streaming_response_get(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_get(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -301,7 +380,6 @@ def test_path_params_get(self, client: Knock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get_channel_data(self, client: Knock) -> None:
         user = client.users.get_channel_data(
@@ -310,7 +388,6 @@ def test_method_get_channel_data(self, client: Knock) -> None:
         )
         assert_matches_type(ChannelData, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_get_channel_data(self, client: Knock) -> None:
         response = client.users.with_raw_response.get_channel_data(
@@ -323,7 +400,6 @@ def test_raw_response_get_channel_data(self, client: Knock) -> None:
         user = response.parse()
         assert_matches_type(ChannelData, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_get_channel_data(self, client: Knock) -> None:
         with client.users.with_streaming_response.get_channel_data(
@@ -338,7 +414,6 @@ def test_streaming_response_get_channel_data(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_get_channel_data(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -353,7 +428,6 @@ def test_path_params_get_channel_data(self, client: Knock) -> None:
                 channel_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get_preferences(self, client: Knock) -> None:
         user = client.users.get_preferences(
@@ -362,7 +436,6 @@ def test_method_get_preferences(self, client: Knock) -> None:
         )
         assert_matches_type(PreferenceSet, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get_preferences_with_all_params(self, client: Knock) -> None:
         user = client.users.get_preferences(
@@ -372,7 +445,6 @@ def test_method_get_preferences_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(PreferenceSet, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_get_preferences(self, client: Knock) -> None:
         response = client.users.with_raw_response.get_preferences(
@@ -385,7 +457,6 @@ def test_raw_response_get_preferences(self, client: Knock) -> None:
         user = response.parse()
         assert_matches_type(PreferenceSet, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_get_preferences(self, client: Knock) -> None:
         with client.users.with_streaming_response.get_preferences(
@@ -400,7 +471,6 @@ def test_streaming_response_get_preferences(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_get_preferences(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -415,7 +485,6 @@ def test_path_params_get_preferences(self, client: Knock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_messages(self, client: Knock) -> None:
         user = client.users.list_messages(
@@ -423,7 +492,6 @@ def test_method_list_messages(self, client: Knock) -> None:
         )
         assert_matches_type(SyncItemsCursor[Message], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_messages_with_all_params(self, client: Knock) -> None:
         user = client.users.list_messages(
@@ -450,7 +518,6 @@ def test_method_list_messages_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncItemsCursor[Message], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_messages(self, client: Knock) -> None:
         response = client.users.with_raw_response.list_messages(
@@ -462,7 +529,6 @@ def test_raw_response_list_messages(self, client: Knock) -> None:
         user = response.parse()
         assert_matches_type(SyncItemsCursor[Message], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_messages(self, client: Knock) -> None:
         with client.users.with_streaming_response.list_messages(
@@ -476,7 +542,6 @@ def test_streaming_response_list_messages(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_messages(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -484,7 +549,6 @@ def test_path_params_list_messages(self, client: Knock) -> None:
                 user_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_preferences(self, client: Knock) -> None:
         user = client.users.list_preferences(
@@ -492,7 +556,6 @@ def test_method_list_preferences(self, client: Knock) -> None:
         )
         assert_matches_type(UserListPreferencesResponse, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_preferences(self, client: Knock) -> None:
         response = client.users.with_raw_response.list_preferences(
@@ -504,7 +567,6 @@ def test_raw_response_list_preferences(self, client: Knock) -> None:
         user = response.parse()
         assert_matches_type(UserListPreferencesResponse, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_preferences(self, client: Knock) -> None:
         with client.users.with_streaming_response.list_preferences(
@@ -518,7 +580,6 @@ def test_streaming_response_list_preferences(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_preferences(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -526,7 +587,6 @@ def test_path_params_list_preferences(self, client: Knock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_schedules(self, client: Knock) -> None:
         user = client.users.list_schedules(
@@ -534,7 +594,6 @@ def test_method_list_schedules(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Schedule], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_schedules_with_all_params(self, client: Knock) -> None:
         user = client.users.list_schedules(
@@ -547,7 +606,6 @@ def test_method_list_schedules_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Schedule], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_schedules(self, client: Knock) -> None:
         response = client.users.with_raw_response.list_schedules(
@@ -559,7 +617,6 @@ def test_raw_response_list_schedules(self, client: Knock) -> None:
         user = response.parse()
         assert_matches_type(SyncEntriesCursor[Schedule], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_schedules(self, client: Knock) -> None:
         with client.users.with_streaming_response.list_schedules(
@@ -573,7 +630,6 @@ def test_streaming_response_list_schedules(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_schedules(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -581,7 +637,6 @@ def test_path_params_list_schedules(self, client: Knock) -> None:
                 user_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_subscriptions(self, client: Knock) -> None:
         user = client.users.list_subscriptions(
@@ -589,7 +644,6 @@ def test_method_list_subscriptions(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Subscription], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_subscriptions_with_all_params(self, client: Knock) -> None:
         user = client.users.list_subscriptions(
@@ -602,7 +656,6 @@ def test_method_list_subscriptions_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[Subscription], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_subscriptions(self, client: Knock) -> None:
         response = client.users.with_raw_response.list_subscriptions(
@@ -614,7 +667,6 @@ def test_raw_response_list_subscriptions(self, client: Knock) -> None:
         user = response.parse()
         assert_matches_type(SyncEntriesCursor[Subscription], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_subscriptions(self, client: Knock) -> None:
         with client.users.with_streaming_response.list_subscriptions(
@@ -628,7 +680,6 @@ def test_streaming_response_list_subscriptions(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_subscriptions(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -636,7 +687,6 @@ def test_path_params_list_subscriptions(self, client: Knock) -> None:
                 user_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_merge(self, client: Knock) -> None:
         user = client.users.merge(
@@ -645,7 +695,6 @@ def test_method_merge(self, client: Knock) -> None:
         )
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_merge(self, client: Knock) -> None:
         response = client.users.with_raw_response.merge(
@@ -658,7 +707,6 @@ def test_raw_response_merge(self, client: Knock) -> None:
         user = response.parse()
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_merge(self, client: Knock) -> None:
         with client.users.with_streaming_response.merge(
@@ -673,7 +721,6 @@ def test_streaming_response_merge(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_merge(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -682,7 +729,6 @@ def test_path_params_merge(self, client: Knock) -> None:
                 from_user_id="user_1",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set_channel_data(self, client: Knock) -> None:
         user = client.users.set_channel_data(
@@ -692,7 +738,6 @@ def test_method_set_channel_data(self, client: Knock) -> None:
         )
         assert_matches_type(ChannelData, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set_channel_data_with_all_params(self, client: Knock) -> None:
         user = client.users.set_channel_data(
@@ -702,7 +747,6 @@ def test_method_set_channel_data_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(ChannelData, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_set_channel_data(self, client: Knock) -> None:
         response = client.users.with_raw_response.set_channel_data(
@@ -716,7 +760,6 @@ def test_raw_response_set_channel_data(self, client: Knock) -> None:
         user = response.parse()
         assert_matches_type(ChannelData, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_set_channel_data(self, client: Knock) -> None:
         with client.users.with_streaming_response.set_channel_data(
@@ -732,7 +775,6 @@ def test_streaming_response_set_channel_data(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_set_channel_data(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -749,7 +791,6 @@ def test_path_params_set_channel_data(self, client: Knock) -> None:
                 data={"tokens": ["push_token_1"]},
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set_preferences(self, client: Knock) -> None:
         user = client.users.set_preferences(
@@ -758,7 +799,6 @@ def test_method_set_preferences(self, client: Knock) -> None:
         )
         assert_matches_type(PreferenceSet, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
         user = client.users.set_preferences(
@@ -769,11 +809,43 @@ def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
                 "marketing": False,
                 "transactional": {
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": False,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -795,11 +867,43 @@ def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
                 },
             },
             channel_types={
-                "chat": True,
+                "chat": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
                 "email": True,
-                "http": True,
-                "in_app_feed": True,
-                "push": True,
+                "http": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
+                "in_app_feed": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
+                "push": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
                 "sms": {
                     "conditions": [
                         {
@@ -826,11 +930,43 @@ def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
             workflows={
                 "dinosaurs-loose": {
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": False,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -854,7 +990,6 @@ def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(PreferenceSet, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_set_preferences(self, client: Knock) -> None:
         response = client.users.with_raw_response.set_preferences(
@@ -867,7 +1002,6 @@ def test_raw_response_set_preferences(self, client: Knock) -> None:
         user = response.parse()
         assert_matches_type(PreferenceSet, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_set_preferences(self, client: Knock) -> None:
         with client.users.with_streaming_response.set_preferences(
@@ -882,7 +1016,6 @@ def test_streaming_response_set_preferences(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_set_preferences(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -897,7 +1030,6 @@ def test_path_params_set_preferences(self, client: Knock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_unset_channel_data(self, client: Knock) -> None:
         user = client.users.unset_channel_data(
@@ -906,7 +1038,6 @@ def test_method_unset_channel_data(self, client: Knock) -> None:
         )
         assert user is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_unset_channel_data(self, client: Knock) -> None:
         response = client.users.with_raw_response.unset_channel_data(
@@ -919,7 +1050,6 @@ def test_raw_response_unset_channel_data(self, client: Knock) -> None:
         user = response.parse()
         assert user is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_unset_channel_data(self, client: Knock) -> None:
         with client.users.with_streaming_response.unset_channel_data(
@@ -934,7 +1064,6 @@ def test_streaming_response_unset_channel_data(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_unset_channel_data(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -949,13 +1078,60 @@ def test_path_params_unset_channel_data(self, client: Knock) -> None:
                 channel_id="",
             )
 
+    @parametrize
+    def test_method_unset_preferences(self, client: Knock) -> None:
+        user = client.users.unset_preferences(
+            user_id="user_id",
+            id="default",
+        )
+        assert user is None
+
+    @parametrize
+    def test_raw_response_unset_preferences(self, client: Knock) -> None:
+        response = client.users.with_raw_response.unset_preferences(
+            user_id="user_id",
+            id="default",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        user = response.parse()
+        assert user is None
+
+    @parametrize
+    def test_streaming_response_unset_preferences(self, client: Knock) -> None:
+        with client.users.with_streaming_response.unset_preferences(
+            user_id="user_id",
+            id="default",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            user = response.parse()
+            assert user is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_unset_preferences(self, client: Knock) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
+            client.users.with_raw_response.unset_preferences(
+                user_id="",
+                id="default",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
+            client.users.with_raw_response.unset_preferences(
+                user_id="user_id",
+                id="",
+            )
+
 
 class TestAsyncUsers:
     parametrize = pytest.mark.parametrize(
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_update(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.update(
@@ -963,7 +1139,6 @@ async def test_method_update(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_update_with_all_params(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.update(
@@ -982,11 +1157,43 @@ async def test_method_update_with_all_params(self, async_client: AsyncKnock) ->
                         "marketing": False,
                         "transactional": {
                             "channel_types": {
-                                "chat": True,
+                                "chat": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "email": False,
-                                "http": True,
-                                "in_app_feed": True,
-                                "push": True,
+                                "http": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "in_app_feed": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "push": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "sms": {
                                     "conditions": [
                                         {
@@ -1008,11 +1215,43 @@ async def test_method_update_with_all_params(self, async_client: AsyncKnock) ->
                         },
                     },
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": True,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -1039,11 +1278,43 @@ async def test_method_update_with_all_params(self, async_client: AsyncKnock) ->
                     "workflows": {
                         "dinosaurs-loose": {
                             "channel_types": {
-                                "chat": True,
+                                "chat": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "email": True,
-                                "http": True,
-                                "in_app_feed": True,
-                                "push": True,
+                                "http": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "in_app_feed": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
+                                "push": {
+                                    "conditions": [
+                                        {
+                                            "argument": "US",
+                                            "operator": "equal_to",
+                                            "variable": "recipient.country_code",
+                                        }
+                                    ]
+                                },
                                 "sms": {
                                     "conditions": [
                                         {
@@ -1070,7 +1341,6 @@ async def test_method_update_with_all_params(self, async_client: AsyncKnock) ->
         )
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.update(
@@ -1082,7 +1352,6 @@ async def test_raw_response_update(self, async_client: AsyncKnock) -> None:
         user = await response.parse()
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.update(
@@ -1096,7 +1365,6 @@ async def test_streaming_response_update(self, async_client: AsyncKnock) -> None
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_update(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1104,13 +1372,11 @@ async def test_path_params_update(self, async_client: AsyncKnock) -> None:
                 user_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.list()
         assert_matches_type(AsyncEntriesCursor[User], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.list(
@@ -1121,7 +1387,6 @@ async def test_method_list_with_all_params(self, async_client: AsyncKnock) -> No
         )
         assert_matches_type(AsyncEntriesCursor[User], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.list()
@@ -1131,7 +1396,6 @@ async def test_raw_response_list(self, async_client: AsyncKnock) -> None:
         user = await response.parse()
         assert_matches_type(AsyncEntriesCursor[User], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.list() as response:
@@ -1143,7 +1407,6 @@ async def test_streaming_response_list(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_delete(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.delete(
@@ -1151,7 +1414,6 @@ async def test_method_delete(self, async_client: AsyncKnock) -> None:
         )
         assert user is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.delete(
@@ -1163,7 +1425,6 @@ async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         user = await response.parse()
         assert user is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.delete(
@@ -1177,7 +1438,6 @@ async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1185,7 +1445,6 @@ async def test_path_params_delete(self, async_client: AsyncKnock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.get(
@@ -1193,7 +1452,6 @@ async def test_method_get(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_get(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.get(
@@ -1205,7 +1463,6 @@ async def test_raw_response_get(self, async_client: AsyncKnock) -> None:
         user = await response.parse()
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_get(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.get(
@@ -1219,7 +1476,6 @@ async def test_streaming_response_get(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_get(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1227,7 +1483,6 @@ async def test_path_params_get(self, async_client: AsyncKnock) -> None:
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get_channel_data(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.get_channel_data(
@@ -1236,7 +1491,6 @@ async def test_method_get_channel_data(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(ChannelData, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_get_channel_data(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.get_channel_data(
@@ -1249,7 +1503,6 @@ async def test_raw_response_get_channel_data(self, async_client: AsyncKnock) ->
         user = await response.parse()
         assert_matches_type(ChannelData, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_get_channel_data(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.get_channel_data(
@@ -1264,7 +1517,6 @@ async def test_streaming_response_get_channel_data(self, async_client: AsyncKnoc
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_get_channel_data(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1279,7 +1531,6 @@ async def test_path_params_get_channel_data(self, async_client: AsyncKnock) -> N
                 channel_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get_preferences(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.get_preferences(
@@ -1288,7 +1539,6 @@ async def test_method_get_preferences(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(PreferenceSet, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get_preferences_with_all_params(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.get_preferences(
@@ -1298,7 +1548,6 @@ async def test_method_get_preferences_with_all_params(self, async_client: AsyncK
         )
         assert_matches_type(PreferenceSet, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_get_preferences(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.get_preferences(
@@ -1311,7 +1560,6 @@ async def test_raw_response_get_preferences(self, async_client: AsyncKnock) -> N
         user = await response.parse()
         assert_matches_type(PreferenceSet, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_get_preferences(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.get_preferences(
@@ -1326,7 +1574,6 @@ async def test_streaming_response_get_preferences(self, async_client: AsyncKnock
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_get_preferences(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1341,7 +1588,6 @@ async def test_path_params_get_preferences(self, async_client: AsyncKnock) -> No
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_messages(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.list_messages(
@@ -1349,7 +1595,6 @@ async def test_method_list_messages(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(AsyncItemsCursor[Message], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_messages_with_all_params(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.list_messages(
@@ -1376,7 +1621,6 @@ async def test_method_list_messages_with_all_params(self, async_client: AsyncKno
         )
         assert_matches_type(AsyncItemsCursor[Message], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_messages(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.list_messages(
@@ -1388,7 +1632,6 @@ async def test_raw_response_list_messages(self, async_client: AsyncKnock) -> Non
         user = await response.parse()
         assert_matches_type(AsyncItemsCursor[Message], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_messages(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.list_messages(
@@ -1402,7 +1645,6 @@ async def test_streaming_response_list_messages(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_messages(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1410,7 +1652,6 @@ async def test_path_params_list_messages(self, async_client: AsyncKnock) -> None
                 user_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_preferences(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.list_preferences(
@@ -1418,7 +1659,6 @@ async def test_method_list_preferences(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(UserListPreferencesResponse, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_preferences(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.list_preferences(
@@ -1430,7 +1670,6 @@ async def test_raw_response_list_preferences(self, async_client: AsyncKnock) ->
         user = await response.parse()
         assert_matches_type(UserListPreferencesResponse, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_preferences(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.list_preferences(
@@ -1444,7 +1683,6 @@ async def test_streaming_response_list_preferences(self, async_client: AsyncKnoc
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_preferences(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1452,7 +1690,6 @@ async def test_path_params_list_preferences(self, async_client: AsyncKnock) -> N
                 "",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_schedules(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.list_schedules(
@@ -1460,7 +1697,6 @@ async def test_method_list_schedules(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(AsyncEntriesCursor[Schedule], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_schedules_with_all_params(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.list_schedules(
@@ -1473,7 +1709,6 @@ async def test_method_list_schedules_with_all_params(self, async_client: AsyncKn
         )
         assert_matches_type(AsyncEntriesCursor[Schedule], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_schedules(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.list_schedules(
@@ -1485,7 +1720,6 @@ async def test_raw_response_list_schedules(self, async_client: AsyncKnock) -> No
         user = await response.parse()
         assert_matches_type(AsyncEntriesCursor[Schedule], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_schedules(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.list_schedules(
@@ -1499,7 +1733,6 @@ async def test_streaming_response_list_schedules(self, async_client: AsyncKnock)
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_schedules(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1507,7 +1740,6 @@ async def test_path_params_list_schedules(self, async_client: AsyncKnock) -> Non
                 user_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_subscriptions(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.list_subscriptions(
@@ -1515,7 +1747,6 @@ async def test_method_list_subscriptions(self, async_client: AsyncKnock) -> None
         )
         assert_matches_type(AsyncEntriesCursor[Subscription], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_subscriptions_with_all_params(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.list_subscriptions(
@@ -1528,7 +1759,6 @@ async def test_method_list_subscriptions_with_all_params(self, async_client: Asy
         )
         assert_matches_type(AsyncEntriesCursor[Subscription], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_subscriptions(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.list_subscriptions(
@@ -1540,7 +1770,6 @@ async def test_raw_response_list_subscriptions(self, async_client: AsyncKnock) -
         user = await response.parse()
         assert_matches_type(AsyncEntriesCursor[Subscription], user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_subscriptions(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.list_subscriptions(
@@ -1554,7 +1783,6 @@ async def test_streaming_response_list_subscriptions(self, async_client: AsyncKn
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_subscriptions(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1562,7 +1790,6 @@ async def test_path_params_list_subscriptions(self, async_client: AsyncKnock) ->
                 user_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_merge(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.merge(
@@ -1571,7 +1798,6 @@ async def test_method_merge(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_merge(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.merge(
@@ -1584,7 +1810,6 @@ async def test_raw_response_merge(self, async_client: AsyncKnock) -> None:
         user = await response.parse()
         assert_matches_type(User, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_merge(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.merge(
@@ -1599,7 +1824,6 @@ async def test_streaming_response_merge(self, async_client: AsyncKnock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_merge(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1608,7 +1832,6 @@ async def test_path_params_merge(self, async_client: AsyncKnock) -> None:
                 from_user_id="user_1",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set_channel_data(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.set_channel_data(
@@ -1618,7 +1841,6 @@ async def test_method_set_channel_data(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(ChannelData, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set_channel_data_with_all_params(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.set_channel_data(
@@ -1628,7 +1850,6 @@ async def test_method_set_channel_data_with_all_params(self, async_client: Async
         )
         assert_matches_type(ChannelData, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_set_channel_data(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.set_channel_data(
@@ -1642,7 +1863,6 @@ async def test_raw_response_set_channel_data(self, async_client: AsyncKnock) ->
         user = await response.parse()
         assert_matches_type(ChannelData, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_set_channel_data(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.set_channel_data(
@@ -1658,7 +1878,6 @@ async def test_streaming_response_set_channel_data(self, async_client: AsyncKnoc
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_set_channel_data(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1675,7 +1894,6 @@ async def test_path_params_set_channel_data(self, async_client: AsyncKnock) -> N
                 data={"tokens": ["push_token_1"]},
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set_preferences(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.set_preferences(
@@ -1684,7 +1902,6 @@ async def test_method_set_preferences(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(PreferenceSet, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set_preferences_with_all_params(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.set_preferences(
@@ -1695,11 +1912,43 @@ async def test_method_set_preferences_with_all_params(self, async_client: AsyncK
                 "marketing": False,
                 "transactional": {
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": False,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -1721,11 +1970,43 @@ async def test_method_set_preferences_with_all_params(self, async_client: AsyncK
                 },
             },
             channel_types={
-                "chat": True,
+                "chat": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
                 "email": True,
-                "http": True,
-                "in_app_feed": True,
-                "push": True,
+                "http": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
+                "in_app_feed": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
+                "push": {
+                    "conditions": [
+                        {
+                            "argument": "US",
+                            "operator": "equal_to",
+                            "variable": "recipient.country_code",
+                        }
+                    ]
+                },
                 "sms": {
                     "conditions": [
                         {
@@ -1752,11 +2033,43 @@ async def test_method_set_preferences_with_all_params(self, async_client: AsyncK
             workflows={
                 "dinosaurs-loose": {
                     "channel_types": {
-                        "chat": True,
+                        "chat": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "email": False,
-                        "http": True,
-                        "in_app_feed": True,
-                        "push": True,
+                        "http": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "in_app_feed": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
+                        "push": {
+                            "conditions": [
+                                {
+                                    "argument": "US",
+                                    "operator": "equal_to",
+                                    "variable": "recipient.country_code",
+                                }
+                            ]
+                        },
                         "sms": {
                             "conditions": [
                                 {
@@ -1780,7 +2093,6 @@ async def test_method_set_preferences_with_all_params(self, async_client: AsyncK
         )
         assert_matches_type(PreferenceSet, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_set_preferences(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.set_preferences(
@@ -1793,7 +2105,6 @@ async def test_raw_response_set_preferences(self, async_client: AsyncKnock) -> N
         user = await response.parse()
         assert_matches_type(PreferenceSet, user, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_set_preferences(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.set_preferences(
@@ -1808,7 +2119,6 @@ async def test_streaming_response_set_preferences(self, async_client: AsyncKnock
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_set_preferences(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1823,7 +2133,6 @@ async def test_path_params_set_preferences(self, async_client: AsyncKnock) -> No
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_unset_channel_data(self, async_client: AsyncKnock) -> None:
         user = await async_client.users.unset_channel_data(
@@ -1832,7 +2141,6 @@ async def test_method_unset_channel_data(self, async_client: AsyncKnock) -> None
         )
         assert user is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_unset_channel_data(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.with_raw_response.unset_channel_data(
@@ -1845,7 +2153,6 @@ async def test_raw_response_unset_channel_data(self, async_client: AsyncKnock) -
         user = await response.parse()
         assert user is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_unset_channel_data(self, async_client: AsyncKnock) -> None:
         async with async_client.users.with_streaming_response.unset_channel_data(
@@ -1860,7 +2167,6 @@ async def test_streaming_response_unset_channel_data(self, async_client: AsyncKn
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_unset_channel_data(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -1874,3 +2180,51 @@ async def test_path_params_unset_channel_data(self, async_client: AsyncKnock) ->
                 user_id="user_id",
                 channel_id="",
             )
+
+    @parametrize
+    async def test_method_unset_preferences(self, async_client: AsyncKnock) -> None:
+        user = await async_client.users.unset_preferences(
+            user_id="user_id",
+            id="default",
+        )
+        assert user is None
+
+    @parametrize
+    async def test_raw_response_unset_preferences(self, async_client: AsyncKnock) -> None:
+        response = await async_client.users.with_raw_response.unset_preferences(
+            user_id="user_id",
+            id="default",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        user = await response.parse()
+        assert user is None
+
+    @parametrize
+    async def test_streaming_response_unset_preferences(self, async_client: AsyncKnock) -> None:
+        async with async_client.users.with_streaming_response.unset_preferences(
+            user_id="user_id",
+            id="default",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            user = await response.parse()
+            assert user is None
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_unset_preferences(self, async_client: AsyncKnock) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
+            await async_client.users.with_raw_response.unset_preferences(
+                user_id="",
+                id="default",
+            )
+
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
+            await async_client.users.with_raw_response.unset_preferences(
+                user_id="user_id",
+                id="",
+            )
diff --git a/tests/api_resources/test_workflow_recipient_runs.py b/tests/api_resources/test_workflow_recipient_runs.py
new file mode 100644
index 00000000..65b92057
--- /dev/null
+++ b/tests/api_resources/test_workflow_recipient_runs.py
@@ -0,0 +1,187 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import os
+from typing import Any, cast
+
+import pytest
+
+from knockapi import Knock, AsyncKnock
+from tests.utils import assert_matches_type
+from knockapi.types import (
+    WorkflowRecipientRun,
+    WorkflowRecipientRunDetail,
+)
+from knockapi._utils import parse_datetime
+from knockapi.pagination import SyncItemsCursor, AsyncItemsCursor
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestWorkflowRecipientRuns:
+    parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+    @parametrize
+    def test_method_list(self, client: Knock) -> None:
+        workflow_recipient_run = client.workflow_recipient_runs.list()
+        assert_matches_type(SyncItemsCursor[WorkflowRecipientRun], workflow_recipient_run, path=["response"])
+
+    @parametrize
+    def test_method_list_with_all_params(self, client: Knock) -> None:
+        workflow_recipient_run = client.workflow_recipient_runs.list(
+            after="after",
+            before="before",
+            ending_at=parse_datetime("2019-12-27T18:11:19.117Z"),
+            has_errors=True,
+            page_size=0,
+            recipient="user_123",
+            starting_at=parse_datetime("2019-12-27T18:11:19.117Z"),
+            status=["queued"],
+            tenant="tenant",
+            workflow="workflow",
+        )
+        assert_matches_type(SyncItemsCursor[WorkflowRecipientRun], workflow_recipient_run, path=["response"])
+
+    @parametrize
+    def test_raw_response_list(self, client: Knock) -> None:
+        response = client.workflow_recipient_runs.with_raw_response.list()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        workflow_recipient_run = response.parse()
+        assert_matches_type(SyncItemsCursor[WorkflowRecipientRun], workflow_recipient_run, path=["response"])
+
+    @parametrize
+    def test_streaming_response_list(self, client: Knock) -> None:
+        with client.workflow_recipient_runs.with_streaming_response.list() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            workflow_recipient_run = response.parse()
+            assert_matches_type(SyncItemsCursor[WorkflowRecipientRun], workflow_recipient_run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_get(self, client: Knock) -> None:
+        workflow_recipient_run = client.workflow_recipient_runs.get(
+            "id",
+        )
+        assert_matches_type(WorkflowRecipientRunDetail, workflow_recipient_run, path=["response"])
+
+    @parametrize
+    def test_raw_response_get(self, client: Knock) -> None:
+        response = client.workflow_recipient_runs.with_raw_response.get(
+            "id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        workflow_recipient_run = response.parse()
+        assert_matches_type(WorkflowRecipientRunDetail, workflow_recipient_run, path=["response"])
+
+    @parametrize
+    def test_streaming_response_get(self, client: Knock) -> None:
+        with client.workflow_recipient_runs.with_streaming_response.get(
+            "id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            workflow_recipient_run = response.parse()
+            assert_matches_type(WorkflowRecipientRunDetail, workflow_recipient_run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_get(self, client: Knock) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
+            client.workflow_recipient_runs.with_raw_response.get(
+                "",
+            )
+
+
+class TestAsyncWorkflowRecipientRuns:
+    parametrize = pytest.mark.parametrize(
+        "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
+    )
+
+    @parametrize
+    async def test_method_list(self, async_client: AsyncKnock) -> None:
+        workflow_recipient_run = await async_client.workflow_recipient_runs.list()
+        assert_matches_type(AsyncItemsCursor[WorkflowRecipientRun], workflow_recipient_run, path=["response"])
+
+    @parametrize
+    async def test_method_list_with_all_params(self, async_client: AsyncKnock) -> None:
+        workflow_recipient_run = await async_client.workflow_recipient_runs.list(
+            after="after",
+            before="before",
+            ending_at=parse_datetime("2019-12-27T18:11:19.117Z"),
+            has_errors=True,
+            page_size=0,
+            recipient="user_123",
+            starting_at=parse_datetime("2019-12-27T18:11:19.117Z"),
+            status=["queued"],
+            tenant="tenant",
+            workflow="workflow",
+        )
+        assert_matches_type(AsyncItemsCursor[WorkflowRecipientRun], workflow_recipient_run, path=["response"])
+
+    @parametrize
+    async def test_raw_response_list(self, async_client: AsyncKnock) -> None:
+        response = await async_client.workflow_recipient_runs.with_raw_response.list()
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        workflow_recipient_run = await response.parse()
+        assert_matches_type(AsyncItemsCursor[WorkflowRecipientRun], workflow_recipient_run, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_list(self, async_client: AsyncKnock) -> None:
+        async with async_client.workflow_recipient_runs.with_streaming_response.list() as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            workflow_recipient_run = await response.parse()
+            assert_matches_type(AsyncItemsCursor[WorkflowRecipientRun], workflow_recipient_run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_get(self, async_client: AsyncKnock) -> None:
+        workflow_recipient_run = await async_client.workflow_recipient_runs.get(
+            "id",
+        )
+        assert_matches_type(WorkflowRecipientRunDetail, workflow_recipient_run, path=["response"])
+
+    @parametrize
+    async def test_raw_response_get(self, async_client: AsyncKnock) -> None:
+        response = await async_client.workflow_recipient_runs.with_raw_response.get(
+            "id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        workflow_recipient_run = await response.parse()
+        assert_matches_type(WorkflowRecipientRunDetail, workflow_recipient_run, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_get(self, async_client: AsyncKnock) -> None:
+        async with async_client.workflow_recipient_runs.with_streaming_response.get(
+            "id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            workflow_recipient_run = await response.parse()
+            assert_matches_type(WorkflowRecipientRunDetail, workflow_recipient_run, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_get(self, async_client: AsyncKnock) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
+            await async_client.workflow_recipient_runs.with_raw_response.get(
+                "",
+            )
diff --git a/tests/api_resources/test_workflows.py b/tests/api_resources/test_workflows.py
index 3c175307..76532392 100644
--- a/tests/api_resources/test_workflows.py
+++ b/tests/api_resources/test_workflows.py
@@ -19,7 +19,6 @@
 class TestWorkflows:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_cancel(self, client: Knock) -> None:
         workflow = client.workflows.cancel(
@@ -28,7 +27,6 @@ def test_method_cancel(self, client: Knock) -> None:
         )
         assert workflow is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_cancel_with_all_params(self, client: Knock) -> None:
         workflow = client.workflows.cancel(
@@ -38,7 +36,6 @@ def test_method_cancel_with_all_params(self, client: Knock) -> None:
         )
         assert workflow is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_cancel(self, client: Knock) -> None:
         response = client.workflows.with_raw_response.cancel(
@@ -51,7 +48,6 @@ def test_raw_response_cancel(self, client: Knock) -> None:
         workflow = response.parse()
         assert workflow is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_cancel(self, client: Knock) -> None:
         with client.workflows.with_streaming_response.cancel(
@@ -66,7 +62,6 @@ def test_streaming_response_cancel(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_cancel(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"):
@@ -75,7 +70,6 @@ def test_path_params_cancel(self, client: Knock) -> None:
                 cancellation_key="cancel-workflow-123",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_trigger(self, client: Knock) -> None:
         workflow = client.workflows.trigger(
@@ -84,7 +78,6 @@ def test_method_trigger(self, client: Knock) -> None:
         )
         assert_matches_type(WorkflowTriggerResponse, workflow, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_trigger_with_all_params(self, client: Knock) -> None:
         workflow = client.workflows.trigger(
@@ -104,7 +97,6 @@ def test_method_trigger_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(WorkflowTriggerResponse, workflow, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_trigger(self, client: Knock) -> None:
         response = client.workflows.with_raw_response.trigger(
@@ -117,7 +109,6 @@ def test_raw_response_trigger(self, client: Knock) -> None:
         workflow = response.parse()
         assert_matches_type(WorkflowTriggerResponse, workflow, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_trigger(self, client: Knock) -> None:
         with client.workflows.with_streaming_response.trigger(
@@ -132,7 +123,6 @@ def test_streaming_response_trigger(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_trigger(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"):
@@ -147,7 +137,6 @@ class TestAsyncWorkflows:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_cancel(self, async_client: AsyncKnock) -> None:
         workflow = await async_client.workflows.cancel(
@@ -156,7 +145,6 @@ async def test_method_cancel(self, async_client: AsyncKnock) -> None:
         )
         assert workflow is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_cancel_with_all_params(self, async_client: AsyncKnock) -> None:
         workflow = await async_client.workflows.cancel(
@@ -166,7 +154,6 @@ async def test_method_cancel_with_all_params(self, async_client: AsyncKnock) ->
         )
         assert workflow is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_cancel(self, async_client: AsyncKnock) -> None:
         response = await async_client.workflows.with_raw_response.cancel(
@@ -179,7 +166,6 @@ async def test_raw_response_cancel(self, async_client: AsyncKnock) -> None:
         workflow = await response.parse()
         assert workflow is None
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_cancel(self, async_client: AsyncKnock) -> None:
         async with async_client.workflows.with_streaming_response.cancel(
@@ -194,7 +180,6 @@ async def test_streaming_response_cancel(self, async_client: AsyncKnock) -> None
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_cancel(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"):
@@ -203,7 +188,6 @@ async def test_path_params_cancel(self, async_client: AsyncKnock) -> None:
                 cancellation_key="cancel-workflow-123",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_trigger(self, async_client: AsyncKnock) -> None:
         workflow = await async_client.workflows.trigger(
@@ -212,7 +196,6 @@ async def test_method_trigger(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(WorkflowTriggerResponse, workflow, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_trigger_with_all_params(self, async_client: AsyncKnock) -> None:
         workflow = await async_client.workflows.trigger(
@@ -232,7 +215,6 @@ async def test_method_trigger_with_all_params(self, async_client: AsyncKnock) ->
         )
         assert_matches_type(WorkflowTriggerResponse, workflow, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_trigger(self, async_client: AsyncKnock) -> None:
         response = await async_client.workflows.with_raw_response.trigger(
@@ -245,7 +227,6 @@ async def test_raw_response_trigger(self, async_client: AsyncKnock) -> None:
         workflow = await response.parse()
         assert_matches_type(WorkflowTriggerResponse, workflow, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_trigger(self, async_client: AsyncKnock) -> None:
         async with async_client.workflows.with_streaming_response.trigger(
@@ -260,7 +241,6 @@ async def test_streaming_response_trigger(self, async_client: AsyncKnock) -> Non
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_trigger(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `key` but received ''"):
diff --git a/tests/api_resources/users/test_bulk.py b/tests/api_resources/users/test_bulk.py
index d7acf43f..537d6c80 100644
--- a/tests/api_resources/users/test_bulk.py
+++ b/tests/api_resources/users/test_bulk.py
@@ -17,7 +17,6 @@
 class TestBulk:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_delete(self, client: Knock) -> None:
         bulk = client.users.bulk.delete(
@@ -25,7 +24,6 @@ def test_method_delete(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_delete(self, client: Knock) -> None:
         response = client.users.bulk.with_raw_response.delete(
@@ -37,7 +35,6 @@ def test_raw_response_delete(self, client: Knock) -> None:
         bulk = response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_delete(self, client: Knock) -> None:
         with client.users.bulk.with_streaming_response.delete(
@@ -51,7 +48,6 @@ def test_streaming_response_delete(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_identify(self, client: Knock) -> None:
         bulk = client.users.bulk.identify(
@@ -59,7 +55,6 @@ def test_method_identify(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_identify(self, client: Knock) -> None:
         response = client.users.bulk.with_raw_response.identify(
@@ -71,7 +66,6 @@ def test_raw_response_identify(self, client: Knock) -> None:
         bulk = response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_identify(self, client: Knock) -> None:
         with client.users.bulk.with_streaming_response.identify(
@@ -85,7 +79,6 @@ def test_streaming_response_identify(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set_preferences(self, client: Knock) -> None:
         bulk = client.users.bulk.set_preferences(
@@ -94,7 +87,6 @@ def test_method_set_preferences(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
         bulk = client.users.bulk.set_preferences(
@@ -104,11 +96,43 @@ def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
                     "marketing": False,
                     "transactional": {
                         "channel_types": {
-                            "chat": True,
+                            "chat": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
                             "email": False,
-                            "http": True,
-                            "in_app_feed": True,
-                            "push": True,
+                            "http": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
+                            "in_app_feed": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
+                            "push": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
                             "sms": {
                                 "conditions": [
                                     {
@@ -130,11 +154,43 @@ def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
                     },
                 },
                 "channel_types": {
-                    "chat": True,
+                    "chat": {
+                        "conditions": [
+                            {
+                                "argument": "US",
+                                "operator": "equal_to",
+                                "variable": "recipient.country_code",
+                            }
+                        ]
+                    },
                     "email": True,
-                    "http": True,
-                    "in_app_feed": True,
-                    "push": True,
+                    "http": {
+                        "conditions": [
+                            {
+                                "argument": "US",
+                                "operator": "equal_to",
+                                "variable": "recipient.country_code",
+                            }
+                        ]
+                    },
+                    "in_app_feed": {
+                        "conditions": [
+                            {
+                                "argument": "US",
+                                "operator": "equal_to",
+                                "variable": "recipient.country_code",
+                            }
+                        ]
+                    },
+                    "push": {
+                        "conditions": [
+                            {
+                                "argument": "US",
+                                "operator": "equal_to",
+                                "variable": "recipient.country_code",
+                            }
+                        ]
+                    },
                     "sms": {
                         "conditions": [
                             {
@@ -161,11 +217,43 @@ def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
                 "workflows": {
                     "dinosaurs-loose": {
                         "channel_types": {
-                            "chat": True,
+                            "chat": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
                             "email": False,
-                            "http": True,
-                            "in_app_feed": True,
-                            "push": True,
+                            "http": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
+                            "in_app_feed": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
+                            "push": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
                             "sms": {
                                 "conditions": [
                                     {
@@ -191,7 +279,6 @@ def test_method_set_preferences_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_set_preferences(self, client: Knock) -> None:
         response = client.users.bulk.with_raw_response.set_preferences(
@@ -204,7 +291,6 @@ def test_raw_response_set_preferences(self, client: Knock) -> None:
         bulk = response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_set_preferences(self, client: Knock) -> None:
         with client.users.bulk.with_streaming_response.set_preferences(
@@ -225,7 +311,6 @@ class TestAsyncBulk:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_delete(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.users.bulk.delete(
@@ -233,7 +318,6 @@ async def test_method_delete(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.bulk.with_raw_response.delete(
@@ -245,7 +329,6 @@ async def test_raw_response_delete(self, async_client: AsyncKnock) -> None:
         bulk = await response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None:
         async with async_client.users.bulk.with_streaming_response.delete(
@@ -259,7 +342,6 @@ async def test_streaming_response_delete(self, async_client: AsyncKnock) -> None
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_identify(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.users.bulk.identify(
@@ -267,7 +349,6 @@ async def test_method_identify(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_identify(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.bulk.with_raw_response.identify(
@@ -279,7 +360,6 @@ async def test_raw_response_identify(self, async_client: AsyncKnock) -> None:
         bulk = await response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_identify(self, async_client: AsyncKnock) -> None:
         async with async_client.users.bulk.with_streaming_response.identify(
@@ -293,7 +373,6 @@ async def test_streaming_response_identify(self, async_client: AsyncKnock) -> No
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set_preferences(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.users.bulk.set_preferences(
@@ -302,7 +381,6 @@ async def test_method_set_preferences(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_set_preferences_with_all_params(self, async_client: AsyncKnock) -> None:
         bulk = await async_client.users.bulk.set_preferences(
@@ -312,11 +390,43 @@ async def test_method_set_preferences_with_all_params(self, async_client: AsyncK
                     "marketing": False,
                     "transactional": {
                         "channel_types": {
-                            "chat": True,
+                            "chat": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
                             "email": False,
-                            "http": True,
-                            "in_app_feed": True,
-                            "push": True,
+                            "http": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
+                            "in_app_feed": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
+                            "push": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
                             "sms": {
                                 "conditions": [
                                     {
@@ -338,11 +448,43 @@ async def test_method_set_preferences_with_all_params(self, async_client: AsyncK
                     },
                 },
                 "channel_types": {
-                    "chat": True,
+                    "chat": {
+                        "conditions": [
+                            {
+                                "argument": "US",
+                                "operator": "equal_to",
+                                "variable": "recipient.country_code",
+                            }
+                        ]
+                    },
                     "email": True,
-                    "http": True,
-                    "in_app_feed": True,
-                    "push": True,
+                    "http": {
+                        "conditions": [
+                            {
+                                "argument": "US",
+                                "operator": "equal_to",
+                                "variable": "recipient.country_code",
+                            }
+                        ]
+                    },
+                    "in_app_feed": {
+                        "conditions": [
+                            {
+                                "argument": "US",
+                                "operator": "equal_to",
+                                "variable": "recipient.country_code",
+                            }
+                        ]
+                    },
+                    "push": {
+                        "conditions": [
+                            {
+                                "argument": "US",
+                                "operator": "equal_to",
+                                "variable": "recipient.country_code",
+                            }
+                        ]
+                    },
                     "sms": {
                         "conditions": [
                             {
@@ -369,11 +511,43 @@ async def test_method_set_preferences_with_all_params(self, async_client: AsyncK
                 "workflows": {
                     "dinosaurs-loose": {
                         "channel_types": {
-                            "chat": True,
+                            "chat": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
                             "email": False,
-                            "http": True,
-                            "in_app_feed": True,
-                            "push": True,
+                            "http": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
+                            "in_app_feed": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
+                            "push": {
+                                "conditions": [
+                                    {
+                                        "argument": "US",
+                                        "operator": "equal_to",
+                                        "variable": "recipient.country_code",
+                                    }
+                                ]
+                            },
                             "sms": {
                                 "conditions": [
                                     {
@@ -399,7 +573,6 @@ async def test_method_set_preferences_with_all_params(self, async_client: AsyncK
         )
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_set_preferences(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.bulk.with_raw_response.set_preferences(
@@ -412,7 +585,6 @@ async def test_raw_response_set_preferences(self, async_client: AsyncKnock) -> N
         bulk = await response.parse()
         assert_matches_type(BulkOperation, bulk, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_set_preferences(self, async_client: AsyncKnock) -> None:
         async with async_client.users.bulk.with_streaming_response.set_preferences(
diff --git a/tests/api_resources/users/test_feeds.py b/tests/api_resources/users/test_feeds.py
index 84b97f6a..4236faba 100644
--- a/tests/api_resources/users/test_feeds.py
+++ b/tests/api_resources/users/test_feeds.py
@@ -18,7 +18,6 @@
 class TestFeeds:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get_settings(self, client: Knock) -> None:
         feed = client.users.feeds.get_settings(
@@ -27,7 +26,6 @@ def test_method_get_settings(self, client: Knock) -> None:
         )
         assert_matches_type(FeedGetSettingsResponse, feed, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_get_settings(self, client: Knock) -> None:
         response = client.users.feeds.with_raw_response.get_settings(
@@ -40,7 +38,6 @@ def test_raw_response_get_settings(self, client: Knock) -> None:
         feed = response.parse()
         assert_matches_type(FeedGetSettingsResponse, feed, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_get_settings(self, client: Knock) -> None:
         with client.users.feeds.with_streaming_response.get_settings(
@@ -55,7 +52,6 @@ def test_streaming_response_get_settings(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_get_settings(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -70,7 +66,6 @@ def test_path_params_get_settings(self, client: Knock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_items(self, client: Knock) -> None:
         feed = client.users.feeds.list_items(
@@ -79,7 +74,6 @@ def test_method_list_items(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[FeedListItemsResponse], feed, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_list_items_with_all_params(self, client: Knock) -> None:
         feed = client.users.feeds.list_items(
@@ -107,7 +101,6 @@ def test_method_list_items_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(SyncEntriesCursor[FeedListItemsResponse], feed, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_list_items(self, client: Knock) -> None:
         response = client.users.feeds.with_raw_response.list_items(
@@ -120,7 +113,6 @@ def test_raw_response_list_items(self, client: Knock) -> None:
         feed = response.parse()
         assert_matches_type(SyncEntriesCursor[FeedListItemsResponse], feed, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_list_items(self, client: Knock) -> None:
         with client.users.feeds.with_streaming_response.list_items(
@@ -135,7 +127,6 @@ def test_streaming_response_list_items(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_list_items(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -156,7 +147,6 @@ class TestAsyncFeeds:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get_settings(self, async_client: AsyncKnock) -> None:
         feed = await async_client.users.feeds.get_settings(
@@ -165,7 +155,6 @@ async def test_method_get_settings(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(FeedGetSettingsResponse, feed, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_get_settings(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.feeds.with_raw_response.get_settings(
@@ -178,7 +167,6 @@ async def test_raw_response_get_settings(self, async_client: AsyncKnock) -> None
         feed = await response.parse()
         assert_matches_type(FeedGetSettingsResponse, feed, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_get_settings(self, async_client: AsyncKnock) -> None:
         async with async_client.users.feeds.with_streaming_response.get_settings(
@@ -193,7 +181,6 @@ async def test_streaming_response_get_settings(self, async_client: AsyncKnock) -
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_get_settings(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -208,7 +195,6 @@ async def test_path_params_get_settings(self, async_client: AsyncKnock) -> None:
                 id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_items(self, async_client: AsyncKnock) -> None:
         feed = await async_client.users.feeds.list_items(
@@ -217,7 +203,6 @@ async def test_method_list_items(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(AsyncEntriesCursor[FeedListItemsResponse], feed, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_list_items_with_all_params(self, async_client: AsyncKnock) -> None:
         feed = await async_client.users.feeds.list_items(
@@ -245,7 +230,6 @@ async def test_method_list_items_with_all_params(self, async_client: AsyncKnock)
         )
         assert_matches_type(AsyncEntriesCursor[FeedListItemsResponse], feed, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_list_items(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.feeds.with_raw_response.list_items(
@@ -258,7 +242,6 @@ async def test_raw_response_list_items(self, async_client: AsyncKnock) -> None:
         feed = await response.parse()
         assert_matches_type(AsyncEntriesCursor[FeedListItemsResponse], feed, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_list_items(self, async_client: AsyncKnock) -> None:
         async with async_client.users.feeds.with_streaming_response.list_items(
@@ -273,7 +256,6 @@ async def test_streaming_response_list_items(self, async_client: AsyncKnock) ->
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_list_items(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
diff --git a/tests/api_resources/users/test_guides.py b/tests/api_resources/users/test_guides.py
index d8c95e8c..fec1ddd9 100644
--- a/tests/api_resources/users/test_guides.py
+++ b/tests/api_resources/users/test_guides.py
@@ -22,7 +22,6 @@
 class TestGuides:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get_channel(self, client: Knock) -> None:
         guide = client.users.guides.get_channel(
@@ -31,7 +30,6 @@ def test_method_get_channel(self, client: Knock) -> None:
         )
         assert_matches_type(GuideGetChannelResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_get_channel_with_all_params(self, client: Knock) -> None:
         guide = client.users.guides.get_channel(
@@ -43,7 +41,6 @@ def test_method_get_channel_with_all_params(self, client: Knock) -> None:
         )
         assert_matches_type(GuideGetChannelResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_get_channel(self, client: Knock) -> None:
         response = client.users.guides.with_raw_response.get_channel(
@@ -56,7 +53,6 @@ def test_raw_response_get_channel(self, client: Knock) -> None:
         guide = response.parse()
         assert_matches_type(GuideGetChannelResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_get_channel(self, client: Knock) -> None:
         with client.users.guides.with_streaming_response.get_channel(
@@ -71,7 +67,6 @@ def test_streaming_response_get_channel(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_get_channel(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -86,7 +81,6 @@ def test_path_params_get_channel(self, client: Knock) -> None:
                 channel_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_message_as_archived(self, client: Knock) -> None:
         guide = client.users.guides.mark_message_as_archived(
@@ -99,7 +93,6 @@ def test_method_mark_message_as_archived(self, client: Knock) -> None:
         )
         assert_matches_type(GuideMarkMessageAsArchivedResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_message_as_archived_with_all_params(self, client: Knock) -> None:
         guide = client.users.guides.mark_message_as_archived(
@@ -128,7 +121,6 @@ def test_method_mark_message_as_archived_with_all_params(self, client: Knock) ->
         )
         assert_matches_type(GuideMarkMessageAsArchivedResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_message_as_archived(self, client: Knock) -> None:
         response = client.users.guides.with_raw_response.mark_message_as_archived(
@@ -145,7 +137,6 @@ def test_raw_response_mark_message_as_archived(self, client: Knock) -> None:
         guide = response.parse()
         assert_matches_type(GuideMarkMessageAsArchivedResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_message_as_archived(self, client: Knock) -> None:
         with client.users.guides.with_streaming_response.mark_message_as_archived(
@@ -164,7 +155,6 @@ def test_streaming_response_mark_message_as_archived(self, client: Knock) -> Non
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_mark_message_as_archived(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -187,7 +177,6 @@ def test_path_params_mark_message_as_archived(self, client: Knock) -> None:
                 guide_step_ref="lab_tours",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_message_as_interacted(self, client: Knock) -> None:
         guide = client.users.guides.mark_message_as_interacted(
@@ -200,7 +189,6 @@ def test_method_mark_message_as_interacted(self, client: Knock) -> None:
         )
         assert_matches_type(GuideMarkMessageAsInteractedResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_message_as_interacted_with_all_params(self, client: Knock) -> None:
         guide = client.users.guides.mark_message_as_interacted(
@@ -229,7 +217,6 @@ def test_method_mark_message_as_interacted_with_all_params(self, client: Knock)
         )
         assert_matches_type(GuideMarkMessageAsInteractedResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_message_as_interacted(self, client: Knock) -> None:
         response = client.users.guides.with_raw_response.mark_message_as_interacted(
@@ -246,7 +233,6 @@ def test_raw_response_mark_message_as_interacted(self, client: Knock) -> None:
         guide = response.parse()
         assert_matches_type(GuideMarkMessageAsInteractedResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_message_as_interacted(self, client: Knock) -> None:
         with client.users.guides.with_streaming_response.mark_message_as_interacted(
@@ -265,7 +251,6 @@ def test_streaming_response_mark_message_as_interacted(self, client: Knock) -> N
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_mark_message_as_interacted(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -288,7 +273,6 @@ def test_path_params_mark_message_as_interacted(self, client: Knock) -> None:
                 guide_step_ref="lab_tours",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_message_as_seen(self, client: Knock) -> None:
         guide = client.users.guides.mark_message_as_seen(
@@ -301,7 +285,6 @@ def test_method_mark_message_as_seen(self, client: Knock) -> None:
         )
         assert_matches_type(GuideMarkMessageAsSeenResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_method_mark_message_as_seen_with_all_params(self, client: Knock) -> None:
         guide = client.users.guides.mark_message_as_seen(
@@ -330,7 +313,6 @@ def test_method_mark_message_as_seen_with_all_params(self, client: Knock) -> Non
         )
         assert_matches_type(GuideMarkMessageAsSeenResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_raw_response_mark_message_as_seen(self, client: Knock) -> None:
         response = client.users.guides.with_raw_response.mark_message_as_seen(
@@ -347,7 +329,6 @@ def test_raw_response_mark_message_as_seen(self, client: Knock) -> None:
         guide = response.parse()
         assert_matches_type(GuideMarkMessageAsSeenResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_streaming_response_mark_message_as_seen(self, client: Knock) -> None:
         with client.users.guides.with_streaming_response.mark_message_as_seen(
@@ -366,7 +347,6 @@ def test_streaming_response_mark_message_as_seen(self, client: Knock) -> None:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     def test_path_params_mark_message_as_seen(self, client: Knock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -395,7 +375,6 @@ class TestAsyncGuides:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get_channel(self, async_client: AsyncKnock) -> None:
         guide = await async_client.users.guides.get_channel(
@@ -404,7 +383,6 @@ async def test_method_get_channel(self, async_client: AsyncKnock) -> None:
         )
         assert_matches_type(GuideGetChannelResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_get_channel_with_all_params(self, async_client: AsyncKnock) -> None:
         guide = await async_client.users.guides.get_channel(
@@ -416,7 +394,6 @@ async def test_method_get_channel_with_all_params(self, async_client: AsyncKnock
         )
         assert_matches_type(GuideGetChannelResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_get_channel(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.guides.with_raw_response.get_channel(
@@ -429,7 +406,6 @@ async def test_raw_response_get_channel(self, async_client: AsyncKnock) -> None:
         guide = await response.parse()
         assert_matches_type(GuideGetChannelResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_get_channel(self, async_client: AsyncKnock) -> None:
         async with async_client.users.guides.with_streaming_response.get_channel(
@@ -444,7 +420,6 @@ async def test_streaming_response_get_channel(self, async_client: AsyncKnock) ->
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_get_channel(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -459,7 +434,6 @@ async def test_path_params_get_channel(self, async_client: AsyncKnock) -> None:
                 channel_id="",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_message_as_archived(self, async_client: AsyncKnock) -> None:
         guide = await async_client.users.guides.mark_message_as_archived(
@@ -472,7 +446,6 @@ async def test_method_mark_message_as_archived(self, async_client: AsyncKnock) -
         )
         assert_matches_type(GuideMarkMessageAsArchivedResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_message_as_archived_with_all_params(self, async_client: AsyncKnock) -> None:
         guide = await async_client.users.guides.mark_message_as_archived(
@@ -501,7 +474,6 @@ async def test_method_mark_message_as_archived_with_all_params(self, async_clien
         )
         assert_matches_type(GuideMarkMessageAsArchivedResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_message_as_archived(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.guides.with_raw_response.mark_message_as_archived(
@@ -518,7 +490,6 @@ async def test_raw_response_mark_message_as_archived(self, async_client: AsyncKn
         guide = await response.parse()
         assert_matches_type(GuideMarkMessageAsArchivedResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_message_as_archived(self, async_client: AsyncKnock) -> None:
         async with async_client.users.guides.with_streaming_response.mark_message_as_archived(
@@ -537,7 +508,6 @@ async def test_streaming_response_mark_message_as_archived(self, async_client: A
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_mark_message_as_archived(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -560,7 +530,6 @@ async def test_path_params_mark_message_as_archived(self, async_client: AsyncKno
                 guide_step_ref="lab_tours",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_message_as_interacted(self, async_client: AsyncKnock) -> None:
         guide = await async_client.users.guides.mark_message_as_interacted(
@@ -573,7 +542,6 @@ async def test_method_mark_message_as_interacted(self, async_client: AsyncKnock)
         )
         assert_matches_type(GuideMarkMessageAsInteractedResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_message_as_interacted_with_all_params(self, async_client: AsyncKnock) -> None:
         guide = await async_client.users.guides.mark_message_as_interacted(
@@ -602,7 +570,6 @@ async def test_method_mark_message_as_interacted_with_all_params(self, async_cli
         )
         assert_matches_type(GuideMarkMessageAsInteractedResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_message_as_interacted(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.guides.with_raw_response.mark_message_as_interacted(
@@ -619,7 +586,6 @@ async def test_raw_response_mark_message_as_interacted(self, async_client: Async
         guide = await response.parse()
         assert_matches_type(GuideMarkMessageAsInteractedResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_message_as_interacted(self, async_client: AsyncKnock) -> None:
         async with async_client.users.guides.with_streaming_response.mark_message_as_interacted(
@@ -638,7 +604,6 @@ async def test_streaming_response_mark_message_as_interacted(self, async_client:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_mark_message_as_interacted(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
@@ -661,7 +626,6 @@ async def test_path_params_mark_message_as_interacted(self, async_client: AsyncK
                 guide_step_ref="lab_tours",
             )
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_message_as_seen(self, async_client: AsyncKnock) -> None:
         guide = await async_client.users.guides.mark_message_as_seen(
@@ -674,7 +638,6 @@ async def test_method_mark_message_as_seen(self, async_client: AsyncKnock) -> No
         )
         assert_matches_type(GuideMarkMessageAsSeenResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_method_mark_message_as_seen_with_all_params(self, async_client: AsyncKnock) -> None:
         guide = await async_client.users.guides.mark_message_as_seen(
@@ -703,7 +666,6 @@ async def test_method_mark_message_as_seen_with_all_params(self, async_client: A
         )
         assert_matches_type(GuideMarkMessageAsSeenResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_raw_response_mark_message_as_seen(self, async_client: AsyncKnock) -> None:
         response = await async_client.users.guides.with_raw_response.mark_message_as_seen(
@@ -720,7 +682,6 @@ async def test_raw_response_mark_message_as_seen(self, async_client: AsyncKnock)
         guide = await response.parse()
         assert_matches_type(GuideMarkMessageAsSeenResponse, guide, path=["response"])
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_streaming_response_mark_message_as_seen(self, async_client: AsyncKnock) -> None:
         async with async_client.users.guides.with_streaming_response.mark_message_as_seen(
@@ -739,7 +700,6 @@ async def test_streaming_response_mark_message_as_seen(self, async_client: Async
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip(reason="Mock server doesn't support callbacks yet")
     @parametrize
     async def test_path_params_mark_message_as_seen(self, async_client: AsyncKnock) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"):
diff --git a/tests/test_client.py b/tests/test_client.py
index 64142ac5..5a35c641 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -427,6 +427,30 @@ def test_default_query_option(self) -> None:
 
         client.close()
 
+    def test_hardcoded_query_params_in_url(self, client: Knock) -> None:
+        request = client._build_request(FinalRequestOptions(method="get", url="/foo?beta=true"))
+        url = httpx.URL(request.url)
+        assert dict(url.params) == {"beta": "true"}
+
+        request = client._build_request(
+            FinalRequestOptions(
+                method="get",
+                url="/foo?beta=true",
+                params={"limit": "10", "page": "abc"},
+            )
+        )
+        url = httpx.URL(request.url)
+        assert dict(url.params) == {"beta": "true", "limit": "10", "page": "abc"}
+
+        request = client._build_request(
+            FinalRequestOptions(
+                method="get",
+                url="/files/a%2Fb?beta=true",
+                params={"limit": "10"},
+            )
+        )
+        assert request.url.raw_path == b"/files/a%2Fb?beta=true&limit=10"
+
     def test_request_extra_json(self, client: Knock) -> None:
         request = client._build_request(
             FinalRequestOptions(
@@ -1347,6 +1371,30 @@ async def test_default_query_option(self) -> None:
 
         await client.close()
 
+    async def test_hardcoded_query_params_in_url(self, async_client: AsyncKnock) -> None:
+        request = async_client._build_request(FinalRequestOptions(method="get", url="/foo?beta=true"))
+        url = httpx.URL(request.url)
+        assert dict(url.params) == {"beta": "true"}
+
+        request = async_client._build_request(
+            FinalRequestOptions(
+                method="get",
+                url="/foo?beta=true",
+                params={"limit": "10", "page": "abc"},
+            )
+        )
+        url = httpx.URL(request.url)
+        assert dict(url.params) == {"beta": "true", "limit": "10", "page": "abc"}
+
+        request = async_client._build_request(
+            FinalRequestOptions(
+                method="get",
+                url="/files/a%2Fb?beta=true",
+                params={"limit": "10"},
+            )
+        )
+        assert request.url.raw_path == b"/files/a%2Fb?beta=true&limit=10"
+
     def test_request_extra_json(self, client: Knock) -> None:
         request = client._build_request(
             FinalRequestOptions(
diff --git a/tests/test_deepcopy.py b/tests/test_deepcopy.py
deleted file mode 100644
index daa7c4b4..00000000
--- a/tests/test_deepcopy.py
+++ /dev/null
@@ -1,58 +0,0 @@
-from knockapi._utils import deepcopy_minimal
-
-
-def assert_different_identities(obj1: object, obj2: object) -> None:
-    assert obj1 == obj2
-    assert id(obj1) != id(obj2)
-
-
-def test_simple_dict() -> None:
-    obj1 = {"foo": "bar"}
-    obj2 = deepcopy_minimal(obj1)
-    assert_different_identities(obj1, obj2)
-
-
-def test_nested_dict() -> None:
-    obj1 = {"foo": {"bar": True}}
-    obj2 = deepcopy_minimal(obj1)
-    assert_different_identities(obj1, obj2)
-    assert_different_identities(obj1["foo"], obj2["foo"])
-
-
-def test_complex_nested_dict() -> None:
-    obj1 = {"foo": {"bar": [{"hello": "world"}]}}
-    obj2 = deepcopy_minimal(obj1)
-    assert_different_identities(obj1, obj2)
-    assert_different_identities(obj1["foo"], obj2["foo"])
-    assert_different_identities(obj1["foo"]["bar"], obj2["foo"]["bar"])
-    assert_different_identities(obj1["foo"]["bar"][0], obj2["foo"]["bar"][0])
-
-
-def test_simple_list() -> None:
-    obj1 = ["a", "b", "c"]
-    obj2 = deepcopy_minimal(obj1)
-    assert_different_identities(obj1, obj2)
-
-
-def test_nested_list() -> None:
-    obj1 = ["a", [1, 2, 3]]
-    obj2 = deepcopy_minimal(obj1)
-    assert_different_identities(obj1, obj2)
-    assert_different_identities(obj1[1], obj2[1])
-
-
-class MyObject: ...
-
-
-def test_ignores_other_types() -> None:
-    # custom classes
-    my_obj = MyObject()
-    obj1 = {"foo": my_obj}
-    obj2 = deepcopy_minimal(obj1)
-    assert_different_identities(obj1, obj2)
-    assert obj1["foo"] is my_obj
-
-    # tuples
-    obj3 = ("a", "b")
-    obj4 = deepcopy_minimal(obj3)
-    assert obj3 is obj4
diff --git a/tests/test_extract_files.py b/tests/test_extract_files.py
index 1fc6cf4f..dc13e213 100644
--- a/tests/test_extract_files.py
+++ b/tests/test_extract_files.py
@@ -35,6 +35,15 @@ def test_multiple_files() -> None:
     assert query == {"documents": [{}, {}]}
 
 
+def test_top_level_file_array() -> None:
+    query = {"files": [b"file one", b"file two"], "title": "hello"}
+    assert extract_files(query, paths=[["files", "<array>"]]) == [
+        ("files[]", b"file one"),
+        ("files[]", b"file two"),
+    ]
+    assert query == {"title": "hello"}
+
+
 @pytest.mark.parametrize(
     "query,paths,expected",
     [
diff --git a/tests/test_files.py b/tests/test_files.py
index 8d7b0a61..641bf93e 100644
--- a/tests/test_files.py
+++ b/tests/test_files.py
@@ -4,7 +4,8 @@
 import pytest
 from dirty_equals import IsDict, IsList, IsBytes, IsTuple
 
-from knockapi._files import to_httpx_files, async_to_httpx_files
+from knockapi._files import to_httpx_files, deepcopy_with_paths, async_to_httpx_files
+from knockapi._utils import extract_files
 
 readme_path = Path(__file__).parent.parent.joinpath("README.md")
 
@@ -49,3 +50,99 @@ def test_string_not_allowed() -> None:
                 "file": "foo",  # type: ignore
             }
         )
+
+
+def assert_different_identities(obj1: object, obj2: object) -> None:
+    assert obj1 == obj2
+    assert obj1 is not obj2
+
+
+class TestDeepcopyWithPaths:
+    def test_copies_top_level_dict(self) -> None:
+        original = {"file": b"data", "other": "value"}
+        result = deepcopy_with_paths(original, [["file"]])
+        assert_different_identities(result, original)
+
+    def test_file_value_is_same_reference(self) -> None:
+        file_bytes = b"contents"
+        original = {"file": file_bytes}
+        result = deepcopy_with_paths(original, [["file"]])
+        assert_different_identities(result, original)
+        assert result["file"] is file_bytes
+
+    def test_list_popped_wholesale(self) -> None:
+        files = [b"f1", b"f2"]
+        original = {"files": files, "title": "t"}
+        result = deepcopy_with_paths(original, [["files", "<array>"]])
+        assert_different_identities(result, original)
+        result_files = result["files"]
+        assert isinstance(result_files, list)
+        assert_different_identities(result_files, files)
+
+    def test_nested_array_path_copies_list_and_elements(self) -> None:
+        elem1 = {"file": b"f1", "extra": 1}
+        elem2 = {"file": b"f2", "extra": 2}
+        original = {"items": [elem1, elem2]}
+        result = deepcopy_with_paths(original, [["items", "<array>", "file"]])
+        assert_different_identities(result, original)
+        result_items = result["items"]
+        assert isinstance(result_items, list)
+        assert_different_identities(result_items, original["items"])
+        assert_different_identities(result_items[0], elem1)
+        assert_different_identities(result_items[1], elem2)
+
+    def test_empty_paths_returns_same_object(self) -> None:
+        original = {"foo": "bar"}
+        result = deepcopy_with_paths(original, [])
+        assert result is original
+
+    def test_multiple_paths(self) -> None:
+        f1 = b"file1"
+        f2 = b"file2"
+        original = {"a": f1, "b": f2, "c": "unchanged"}
+        result = deepcopy_with_paths(original, [["a"], ["b"]])
+        assert_different_identities(result, original)
+        assert result["a"] is f1
+        assert result["b"] is f2
+        assert result["c"] is original["c"]
+
+    def test_extract_files_does_not_mutate_original_top_level(self) -> None:
+        file_bytes = b"contents"
+        original = {"file": file_bytes, "other": "value"}
+
+        copied = deepcopy_with_paths(original, [["file"]])
+        extracted = extract_files(copied, paths=[["file"]])
+
+        assert extracted == [("file", file_bytes)]
+        assert original == {"file": file_bytes, "other": "value"}
+        assert copied == {"other": "value"}
+
+    def test_extract_files_does_not_mutate_original_nested_array_path(self) -> None:
+        file1 = b"f1"
+        file2 = b"f2"
+        original = {
+            "items": [
+                {"file": file1, "extra": 1},
+                {"file": file2, "extra": 2},
+            ],
+            "title": "example",
+        }
+
+        copied = deepcopy_with_paths(original, [["items", "<array>", "file"]])
+        extracted = extract_files(copied, paths=[["items", "<array>", "file"]])
+
+        assert extracted == [("items[][file]", file1), ("items[][file]", file2)]
+        assert original == {
+            "items": [
+                {"file": file1, "extra": 1},
+                {"file": file2, "extra": 2},
+            ],
+            "title": "example",
+        }
+        assert copied == {
+            "items": [
+                {"extra": 1},
+                {"extra": 2},
+            ],
+            "title": "example",
+        }
diff --git a/tests/test_utils/test_path.py b/tests/test_utils/test_path.py
new file mode 100644
index 00000000..4740481f
--- /dev/null
+++ b/tests/test_utils/test_path.py
@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from knockapi._utils._path import path_template
+
+
+@pytest.mark.parametrize(
+    "template, kwargs, expected",
+    [
+        ("/v1/{id}", dict(id="abc"), "/v1/abc"),
+        ("/v1/{a}/{b}", dict(a="x", b="y"), "/v1/x/y"),
+        ("/v1/{a}{b}/path/{c}?val={d}#{e}", dict(a="x", b="y", c="z", d="u", e="v"), "/v1/xy/path/z?val=u#v"),
+        ("/{w}/{w}", dict(w="echo"), "/echo/echo"),
+        ("/v1/static", {}, "/v1/static"),
+        ("", {}, ""),
+        ("/v1/?q={n}&count=10", dict(n=42), "/v1/?q=42&count=10"),
+        ("/v1/{v}", dict(v=None), "/v1/null"),
+        ("/v1/{v}", dict(v=True), "/v1/true"),
+        ("/v1/{v}", dict(v=False), "/v1/false"),
+        ("/v1/{v}", dict(v=".hidden"), "/v1/.hidden"),  # dot prefix ok
+        ("/v1/{v}", dict(v="file.txt"), "/v1/file.txt"),  # dot in middle ok
+        ("/v1/{v}", dict(v="..."), "/v1/..."),  # triple dot ok
+        ("/v1/{a}{b}", dict(a=".", b="txt"), "/v1/.txt"),  # dot var combining with adjacent to be ok
+        ("/items?q={v}#{f}", dict(v=".", f=".."), "/items?q=.#.."),  # dots in query/fragment are fine
+        (
+            "/v1/{a}?query={b}",
+            dict(a="../../other/endpoint", b="a&bad=true"),
+            "/v1/..%2F..%2Fother%2Fendpoint?query=a%26bad%3Dtrue",
+        ),
+        ("/v1/{val}", dict(val="a/b/c"), "/v1/a%2Fb%2Fc"),
+        ("/v1/{val}", dict(val="a/b/c?query=value"), "/v1/a%2Fb%2Fc%3Fquery=value"),
+        ("/v1/{val}", dict(val="a/b/c?query=value&bad=true"), "/v1/a%2Fb%2Fc%3Fquery=value&bad=true"),
+        ("/v1/{val}", dict(val="%20"), "/v1/%2520"),  # escapes escape sequences in input
+        # Query: slash and ? are safe, # is not
+        ("/items?q={v}", dict(v="a/b"), "/items?q=a/b"),
+        ("/items?q={v}", dict(v="a?b"), "/items?q=a?b"),
+        ("/items?q={v}", dict(v="a#b"), "/items?q=a%23b"),
+        ("/items?q={v}", dict(v="a b"), "/items?q=a%20b"),
+        # Fragment: slash and ? are safe
+        ("/docs#{v}", dict(v="a/b"), "/docs#a/b"),
+        ("/docs#{v}", dict(v="a?b"), "/docs#a?b"),
+        # Path: slash, ? and # are all encoded
+        ("/v1/{v}", dict(v="a/b"), "/v1/a%2Fb"),
+        ("/v1/{v}", dict(v="a?b"), "/v1/a%3Fb"),
+        ("/v1/{v}", dict(v="a#b"), "/v1/a%23b"),
+        # same var encoded differently by component
+        (
+            "/v1/{v}?q={v}#{v}",
+            dict(v="a/b?c#d"),
+            "/v1/a%2Fb%3Fc%23d?q=a/b?c%23d#a/b?c%23d",
+        ),
+        ("/v1/{val}", dict(val="x?admin=true"), "/v1/x%3Fadmin=true"),  # query injection
+        ("/v1/{val}", dict(val="x#admin"), "/v1/x%23admin"),  # fragment injection
+    ],
+)
+def test_interpolation(template: str, kwargs: dict[str, Any], expected: str) -> None:
+    assert path_template(template, **kwargs) == expected
+
+
+def test_missing_kwarg_raises_key_error() -> None:
+    with pytest.raises(KeyError, match="org_id"):
+        path_template("/v1/{org_id}")
+
+
+@pytest.mark.parametrize(
+    "template, kwargs",
+    [
+        ("{a}/path", dict(a=".")),
+        ("{a}/path", dict(a="..")),
+        ("/v1/{a}", dict(a=".")),
+        ("/v1/{a}", dict(a="..")),
+        ("/v1/{a}/path", dict(a=".")),
+        ("/v1/{a}/path", dict(a="..")),
+        ("/v1/{a}{b}", dict(a=".", b=".")),  # adjacent vars → ".."
+        ("/v1/{a}.", dict(a=".")),  # var + static → ".."
+        ("/v1/{a}{b}", dict(a="", b=".")),  # empty + dot → "."
+        ("/v1/%2e/{x}", dict(x="ok")),  # encoded dot in static text
+        ("/v1/%2e./{x}", dict(x="ok")),  # mixed encoded ".." in static
+        ("/v1/.%2E/{x}", dict(x="ok")),  # mixed encoded ".." in static
+        ("/v1/{v}?q=1", dict(v="..")),
+        ("/v1/{v}#frag", dict(v="..")),
+    ],
+)
+def test_dot_segment_rejected(template: str, kwargs: dict[str, Any]) -> None:
+    with pytest.raises(ValueError, match="dot-segment"):
+        path_template(template, **kwargs)
