diff --git a/.github/workflows/backmerge.yaml b/.github/workflows/backmerge.yaml
new file mode 100644
index 0000000..0a8277e
--- /dev/null
+++ b/.github/workflows/backmerge.yaml
@@ -0,0 +1,41 @@
+# Backmerge releases from main to next
+#
+# This workflow ensures that any commits on `main` (releases, version bumps)
+# are automatically merged back into `next` to keep branches in sync.
+#
+# This prevents divergence where main has commits that next doesn't have.
+
+name: Backmerge to next
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: write
+
+jobs:
+  backmerge:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: next
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Merge main into next
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          git fetch origin main
+
+          if git merge-base --is-ancestor origin/main HEAD; then
+            echo "next already contains all commits from main. Nothing to merge."
+            exit 0
+          fi
+
+          git merge origin/main -m "chore: backmerge from main"
+          git push origin next
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..64484ee
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,77 @@
+# Continuous Integration for the python-sdk.
+#
+# Runs the pytest suite across every supported Python version and verifies the
+# package builds and passes twine's metadata checks. Mirrors the gating the
+# other ChatBotKit SDKs have (go/terraform `ci.yml`, node `publish.yml`).
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+      - next
+    paths-ignore:
+      - '**.md'
+      - 'LICENSE'
+  pull_request:
+    branches:
+      - main
+      - next
+    paths-ignore:
+      - '**.md'
+      - 'LICENSE'
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Test (Python ${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.10', '3.11', '3.12', '3.13']
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      - name: Install
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e '.[dev,agent,examples]'
+
+      - name: Test
+        run: pytest
+
+  build:
+    name: Build & metadata check
+    runs-on: ubuntu-latest
+    needs: test
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+          cache: pip
+
+      - name: Install build tooling
+        run: |
+          python -m pip install --upgrade pip
+          pip install build twine
+
+      - name: Build sdist and wheel
+        run: python -m build
+
+      - name: Check metadata
+        run: twine check dist/*
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..0be7a90
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,82 @@
+# Release workflow for the python-sdk.
+#
+# Triggered by tag-release.yml (workflow_dispatch at the new tag) or by a
+# manually pushed `v*` tag. Builds the sdist/wheel, publishes to PyPI (only if
+# a PYPI_API_TOKEN secret is configured), and creates a GitHub Release whose
+# body is the matching section from CHANGELOG.md with auto-generated commit
+# notes appended.
+#
+# To enable PyPI publishing, add a `PYPI_API_TOKEN` secret (a PyPI API token)
+# to this repository. Without it, the build still runs and the GitHub Release is
+# still created; only the upload step is skipped.
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Build sdist and wheel
+        run: |
+          python -m pip install --upgrade pip
+          pip install build twine
+          python -m build
+          twine check dist/*
+
+      - name: Detect PyPI token
+        id: token
+        env:
+          PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          if [ -n "$PYPI_API_TOKEN" ]; then
+            echo "present=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "present=false" >> "$GITHUB_OUTPUT"
+            echo "PYPI_API_TOKEN not set - skipping PyPI upload." >&2
+          fi
+
+      - name: Publish to PyPI
+        if: steps.token.outputs.present == 'true'
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+        run: twine upload --non-interactive dist/*
+
+      - name: Extract changelog section for this version
+        id: changelog
+        run: |
+          VERSION="${GITHUB_REF_NAME#v}"
+          if [ -f CHANGELOG.md ]; then
+            awk -v ver="$VERSION" '
+              $0 ~ ("^## \\[" ver "\\]") { capture = 1; next }
+              capture && /^## \[/ { exit }
+              capture { print }
+            ' CHANGELOG.md > release-notes.md
+          fi
+          if [ ! -s release-notes.md ]; then
+            echo "Release v${VERSION}. See the full changelog in CHANGELOG.md." > release-notes.md
+          fi
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          body_path: release-notes.md
+          generate_release_notes: true
diff --git a/.github/workflows/tag-release.yml b/.github/workflows/tag-release.yml
new file mode 100644
index 0000000..e6f8f23
--- /dev/null
+++ b/.github/workflows/tag-release.yml
@@ -0,0 +1,66 @@
+# Auto-tag when merging to main
+#
+# Reads the version from pyproject.toml and, if the matching tag does not
+# already exist, creates and pushes it, then triggers the release workflow
+# (build + publish to PyPI + GitHub Release).
+name: Tag Release
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write
+  actions: write
+
+jobs:
+  tag:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Get version from pyproject.toml
+        id: version
+        run: |
+          VERSION=$(grep -m1 '^version = ' pyproject.toml | sed -E 's/^version = "(.*)"/\1/')
+          if [ -z "$VERSION" ]; then
+            echo "Could not read version from pyproject.toml" >&2
+            exit 1
+          fi
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "Version: $VERSION"
+
+      - name: Check if tag exists
+        id: check_tag
+        run: |
+          if git rev-parse "v${{ steps.version.outputs.version }}" >/dev/null 2>&1; then
+            echo "exists=true" >> "$GITHUB_OUTPUT"
+            echo "Tag v${{ steps.version.outputs.version }} already exists"
+          else
+            echo "exists=false" >> "$GITHUB_OUTPUT"
+            echo "Tag v${{ steps.version.outputs.version }} does not exist"
+          fi
+
+      - name: Create and push tag
+        if: steps.check_tag.outputs.exists == 'false'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag -a "v${{ steps.version.outputs.version }}" -m "Release v${{ steps.version.outputs.version }}"
+          git push origin "v${{ steps.version.outputs.version }}"
+
+      - name: Trigger release workflow
+        if: steps.check_tag.outputs.exists == 'false'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            await github.rest.actions.createWorkflowDispatch({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              workflow_id: 'release.yml',
+              ref: 'v${{ steps.version.outputs.version }}'
+            })
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..f3a0331
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,28 @@
+# Changelog
+
+All notable changes to the ChatBotKit Python SDK are documented in this file.
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2026-06-22
+
+### Added
+
+- `skill_server` integration client (`client.integration.skill_server`) with
+  `list`, `fetch`, `create`, `update`, and `delete`. The Skill Server
+  integration exposes a skillset's abilities as a text-first HTTP API.
+- `site` client under `space` (`client.space.site`) with `list`, `fetch`,
+  `create`, `update`, and `delete`, keyed by the parent space ID. A space site
+  binds a `<label>.chatbotkit.space` subdomain to static content served from a
+  space's storage.
+
+### Changed
+
+- Re-generated types from the latest API spec, including the `alias` field now
+  present across integration create/update requests.
+
+## [0.1.0] - 2026-06-11
+
+### Added
+
+- Initial release of the async Python SDK for ChatBotKit.
diff --git a/chatbotkit/__init__.py b/chatbotkit/__init__.py
index 57f2209..8da8b8f 100644
--- a/chatbotkit/__init__.py
+++ b/chatbotkit/__init__.py
@@ -9,4 +9,4 @@
     "Response",
 ]
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
diff --git a/chatbotkit/integration.py b/chatbotkit/integration.py
index 8228045..7cb4eb8 100644
--- a/chatbotkit/integration.py
+++ b/chatbotkit/integration.py
@@ -25,6 +25,7 @@ def __init__(self, client: Client) -> None:
         self.twilio = TwilioClient(client)
         self.email = EmailClient(client)
         self.mcp_server = McpServerClient(client)
+        self.skill_server = SkillServerClient(client)
         self.microsoft_teams = MicrosoftTeamsClient(client)
         self.google_chat = GoogleChatClient(client)
         self.trigger = TriggerClient(client)
@@ -995,6 +996,60 @@ def delete(
         )
 
 
+class SkillServerClient:
+    def __init__(self, client: Client) -> None:
+        self._client = client
+
+    def list(
+        self,
+        request: types.SkillServerIntegrationListParams | Request | None = None,
+    ) -> Response[types.SkillServerIntegrationListResponse, types.SkillServerIntegrationListStreamItem]:
+        return self._client.client_fetch(
+            "/api/v1/integration/skillserver/list",
+            query=request,
+            parse=types.SkillServerIntegrationListResponse.from_dict,
+            stream_parse=types.SkillServerIntegrationListStreamItem.from_dict,
+        )
+
+    def fetch(self, integration_id: str) -> Response[types.SkillServerIntegrationFetchResponse, Any]:
+        return self._client.client_fetch(
+            f"/api/v1/integration/skillserver/{integration_id}/fetch",
+            parse=types.SkillServerIntegrationFetchResponse.from_dict,
+        )
+
+    def create(
+        self,
+        request: types.SkillServerIntegrationCreateRequest | Request,
+    ) -> Response[types.SkillServerIntegrationCreateResponse, Any]:
+        return self._client.client_fetch(
+            "/api/v1/integration/skillserver/create",
+            record=request,
+            parse=types.SkillServerIntegrationCreateResponse.from_dict,
+        )
+
+    def update(
+        self,
+        integration_id: str,
+        request: types.SkillServerIntegrationUpdateRequest | Request,
+    ) -> Response[types.SkillServerIntegrationUpdateResponse, Any]:
+        return self._client.client_fetch(
+            f"/api/v1/integration/skillserver/{integration_id}/update",
+            record=request,
+            parse=types.SkillServerIntegrationUpdateResponse.from_dict,
+        )
+
+    def delete(
+        self,
+        integration_id: str,
+        request: Request | None = None,
+    ) -> Response[types.SkillServerIntegrationDeleteResponse, Any]:
+        return self._client.client_fetch(
+            f"/api/v1/integration/skillserver/{integration_id}/delete",
+            record=request or {},
+            parse=types.SkillServerIntegrationDeleteResponse.from_dict,
+        )
+
+
 class MicrosoftTeamsClient:
     def __init__(self, client: Client) -> None:
         self._client = client
diff --git a/chatbotkit/space.py b/chatbotkit/space.py
index 12c685d..b1488d6 100644
--- a/chatbotkit/space.py
+++ b/chatbotkit/space.py
@@ -12,6 +12,7 @@ class SpaceClient:
     def __init__(self, client: Client) -> None:
         self._client = client
         self.storage = SpaceStorageClient(client)
+        self.site = SpaceSiteClient(client)
 
     def list(
         self,
@@ -89,3 +90,61 @@ def delete(
             record=request or {},
             parse=types.SpaceStoragePathDeleteResponse.from_dict,
         )
+
+
+class SpaceSiteClient:
+    def __init__(self, client: Client) -> None:
+        self._client = client
+
+    def list(
+        self,
+        space_id: str,
+        request: types.SpaceSiteListParams | Request | None = None,
+    ) -> Response[types.SpaceSiteListResponse, types.SpaceSiteListStreamItem]:
+        return self._client.client_fetch(
+            f"/api/v1/space/{space_id}/site/list",
+            query=request,
+            parse=types.SpaceSiteListResponse.from_dict,
+            stream_parse=types.SpaceSiteListStreamItem.from_dict,
+        )
+
+    def fetch(self, space_id: str, site_id: str) -> Response[types.SpaceSiteFetchResponse, Any]:
+        return self._client.client_fetch(
+            f"/api/v1/space/{space_id}/site/{site_id}/fetch",
+            parse=types.SpaceSiteFetchResponse.from_dict,
+        )
+
+    def create(
+        self,
+        space_id: str,
+        request: types.SpaceSiteCreateRequest | Request,
+    ) -> Response[types.SpaceSiteCreateResponse, Any]:
+        return self._client.client_fetch(
+            f"/api/v1/space/{space_id}/site/create",
+            record=request,
+            parse=types.SpaceSiteCreateResponse.from_dict,
+        )
+
+    def update(
+        self,
+        space_id: str,
+        site_id: str,
+        request: types.SpaceSiteUpdateRequest | Request,
+    ) -> Response[types.SpaceSiteUpdateResponse, Any]:
+        return self._client.client_fetch(
+            f"/api/v1/space/{space_id}/site/{site_id}/update",
+            record=request,
+            parse=types.SpaceSiteUpdateResponse.from_dict,
+        )
+
+    def delete(
+        self,
+        space_id: str,
+        site_id: str,
+        request: Request | None = None,
+    ) -> Response[types.SpaceSiteDeleteResponse, Any]:
+        return self._client.client_fetch(
+            f"/api/v1/space/{space_id}/site/{site_id}/delete",
+            record=request or {},
+            parse=types.SpaceSiteDeleteResponse.from_dict,
+        )
diff --git a/chatbotkit/types.py b/chatbotkit/types.py
index 341836b..d4a23d3 100644
--- a/chatbotkit/types.py
+++ b/chatbotkit/types.py
@@ -1588,6 +1588,9 @@ class BlueprintFetchResponseVisibility(Enum):
 class BlueprintFetchResponse:
     """Instance list properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
@@ -1609,7 +1612,8 @@ class BlueprintFetchResponse:
     visibility: Optional[BlueprintFetchResponseVisibility]
     """The blueprint visibility"""
 
-    def __init__(self, created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[BlueprintFetchResponseVisibility]) -> None:
+    def __init__(self, alias: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[BlueprintFetchResponseVisibility]) -> None:
+        self.alias = alias
         self.created_at = created_at
         self.description = description
         self.id = id
@@ -1621,6 +1625,7 @@ def __init__(self, created_at: float, description: Optional[str], id: str, meta:
     @staticmethod
     def from_dict(obj: Any) -> 'BlueprintFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
@@ -1628,10 +1633,12 @@ def from_dict(obj: Any) -> 'BlueprintFetchResponse':
         name = from_union([from_str, from_none], obj.get("name"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([BlueprintFetchResponseVisibility, from_none], obj.get("visibility"))
-        return BlueprintFetchResponse(created_at, description, id, meta, name, updated_at, visibility)
+        return BlueprintFetchResponse(alias, created_at, description, id, meta, name, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
@@ -1709,19 +1716,27 @@ def to_dict(self) -> dict:
 
 
 class BlueprintResourcesImportRequest:
+    ensure: Optional[bool]
+    """When true and the blueprint is addressed by the caller's own @alias, it is created if it
+    does not exist yet (idempotent provision). Ignored for a raw id, which still 404s on miss.
+    """
     resources: Dict[str, Any]
 
-    def __init__(self, resources: Dict[str, Any]) -> None:
+    def __init__(self, ensure: Optional[bool], resources: Dict[str, Any]) -> None:
+        self.ensure = ensure
         self.resources = resources
 
     @staticmethod
     def from_dict(obj: Any) -> 'BlueprintResourcesImportRequest':
         assert isinstance(obj, dict)
+        ensure = from_union([from_bool, from_none], obj.get("ensure"))
         resources = from_dict(lambda x: x, obj.get("resources"))
-        return BlueprintResourcesImportRequest(resources)
+        return BlueprintResourcesImportRequest(ensure, resources)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.ensure is not None:
+            result["ensure"] = from_union([from_bool, from_none], self.ensure)
         result["resources"] = from_dict(lambda x: x, self.resources)
         return result
 
@@ -2001,6 +2016,9 @@ class PurpleVisibility(Enum):
 class BlueprintListResponseItem:
     """Instance list properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
@@ -2022,7 +2040,8 @@ class BlueprintListResponseItem:
     visibility: Optional[PurpleVisibility]
     """The blueprint visibility"""
 
-    def __init__(self, created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[PurpleVisibility]) -> None:
+    def __init__(self, alias: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[PurpleVisibility]) -> None:
+        self.alias = alias
         self.created_at = created_at
         self.description = description
         self.id = id
@@ -2034,6 +2053,7 @@ def __init__(self, created_at: float, description: Optional[str], id: str, meta:
     @staticmethod
     def from_dict(obj: Any) -> 'BlueprintListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
@@ -2041,10 +2061,12 @@ def from_dict(obj: Any) -> 'BlueprintListResponseItem':
         name = from_union([from_str, from_none], obj.get("name"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([PurpleVisibility, from_none], obj.get("visibility"))
-        return BlueprintListResponseItem(created_at, description, id, meta, name, updated_at, visibility)
+        return BlueprintListResponseItem(alias, created_at, description, id, meta, name, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
@@ -2094,6 +2116,9 @@ class FluffyVisibility(Enum):
 class BlueprintListStreamItemData:
     """Instance list properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
@@ -2115,7 +2140,8 @@ class BlueprintListStreamItemData:
     visibility: Optional[FluffyVisibility]
     """The blueprint visibility"""
 
-    def __init__(self, created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[FluffyVisibility]) -> None:
+    def __init__(self, alias: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[FluffyVisibility]) -> None:
+        self.alias = alias
         self.created_at = created_at
         self.description = description
         self.id = id
@@ -2127,6 +2153,7 @@ def __init__(self, created_at: float, description: Optional[str], id: str, meta:
     @staticmethod
     def from_dict(obj: Any) -> 'BlueprintListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
@@ -2134,10 +2161,12 @@ def from_dict(obj: Any) -> 'BlueprintListStreamItemData':
         name = from_union([from_str, from_none], obj.get("name"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([FluffyVisibility, from_none], obj.get("visibility"))
-        return BlueprintListStreamItemData(created_at, description, id, meta, name, updated_at, visibility)
+        return BlueprintListStreamItemData(alias, created_at, description, id, meta, name, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
@@ -2353,6 +2382,9 @@ class BotFetchResponseVisibility(Enum):
 class BotFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     backstory: Optional[str]
     """The backstory this configuration is using"""
 
@@ -2395,7 +2427,8 @@ class BotFetchResponse:
     visibility: Optional[BotFetchResponseVisibility]
     """The bot visibility"""
 
-    def __init__(self, backstory: Optional[str], blueprint_id: Optional[str], created_at: float, dataset_id: Optional[str], description: Optional[str], id: str, meta: Optional[Dict[str, Any]], model: Optional[str], moderation: Optional[bool], name: Optional[str], privacy: Optional[bool], skillset_id: Optional[str], updated_at: float, visibility: Optional[BotFetchResponseVisibility]) -> None:
+    def __init__(self, alias: Optional[str], backstory: Optional[str], blueprint_id: Optional[str], created_at: float, dataset_id: Optional[str], description: Optional[str], id: str, meta: Optional[Dict[str, Any]], model: Optional[str], moderation: Optional[bool], name: Optional[str], privacy: Optional[bool], skillset_id: Optional[str], updated_at: float, visibility: Optional[BotFetchResponseVisibility]) -> None:
+        self.alias = alias
         self.backstory = backstory
         self.blueprint_id = blueprint_id
         self.created_at = created_at
@@ -2414,6 +2447,7 @@ def __init__(self, backstory: Optional[str], blueprint_id: Optional[str], create
     @staticmethod
     def from_dict(obj: Any) -> 'BotFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         backstory = from_union([from_str, from_none], obj.get("backstory"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
@@ -2428,10 +2462,12 @@ def from_dict(obj: Any) -> 'BotFetchResponse':
         skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([BotFetchResponseVisibility, from_none], obj.get("visibility"))
-        return BotFetchResponse(backstory, blueprint_id, created_at, dataset_id, description, id, meta, model, moderation, name, privacy, skillset_id, updated_at, visibility)
+        return BotFetchResponse(alias, backstory, blueprint_id, created_at, dataset_id, description, id, meta, model, moderation, name, privacy, skillset_id, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.backstory is not None:
             result["backstory"] = from_union([from_str, from_none], self.backstory)
         if self.blueprint_id is not None:
@@ -3178,6 +3214,9 @@ class TentacledVisibility(Enum):
 class BotListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     backstory: Optional[str]
     """The backstory this configuration is using"""
 
@@ -3220,7 +3259,8 @@ class BotListResponseItem:
     visibility: Optional[TentacledVisibility]
     """The bot visibility"""
 
-    def __init__(self, backstory: Optional[str], blueprint_id: Optional[str], created_at: float, dataset_id: Optional[str], description: Optional[str], id: str, meta: Optional[Dict[str, Any]], model: Optional[str], moderation: Optional[bool], name: Optional[str], privacy: Optional[bool], skillset_id: Optional[str], updated_at: float, visibility: Optional[TentacledVisibility]) -> None:
+    def __init__(self, alias: Optional[str], backstory: Optional[str], blueprint_id: Optional[str], created_at: float, dataset_id: Optional[str], description: Optional[str], id: str, meta: Optional[Dict[str, Any]], model: Optional[str], moderation: Optional[bool], name: Optional[str], privacy: Optional[bool], skillset_id: Optional[str], updated_at: float, visibility: Optional[TentacledVisibility]) -> None:
+        self.alias = alias
         self.backstory = backstory
         self.blueprint_id = blueprint_id
         self.created_at = created_at
@@ -3239,6 +3279,7 @@ def __init__(self, backstory: Optional[str], blueprint_id: Optional[str], create
     @staticmethod
     def from_dict(obj: Any) -> 'BotListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         backstory = from_union([from_str, from_none], obj.get("backstory"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
@@ -3253,10 +3294,12 @@ def from_dict(obj: Any) -> 'BotListResponseItem':
         skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([TentacledVisibility, from_none], obj.get("visibility"))
-        return BotListResponseItem(backstory, blueprint_id, created_at, dataset_id, description, id, meta, model, moderation, name, privacy, skillset_id, updated_at, visibility)
+        return BotListResponseItem(alias, backstory, blueprint_id, created_at, dataset_id, description, id, meta, model, moderation, name, privacy, skillset_id, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.backstory is not None:
             result["backstory"] = from_union([from_str, from_none], self.backstory)
         if self.blueprint_id is not None:
@@ -3320,6 +3363,9 @@ class StickyVisibility(Enum):
 class BotListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     backstory: Optional[str]
     """The backstory this configuration is using"""
 
@@ -3362,7 +3408,8 @@ class BotListStreamItemData:
     visibility: Optional[StickyVisibility]
     """The bot visibility"""
 
-    def __init__(self, backstory: Optional[str], blueprint_id: Optional[str], created_at: float, dataset_id: Optional[str], description: Optional[str], id: str, meta: Optional[Dict[str, Any]], model: Optional[str], moderation: Optional[bool], name: Optional[str], privacy: Optional[bool], skillset_id: Optional[str], updated_at: float, visibility: Optional[StickyVisibility]) -> None:
+    def __init__(self, alias: Optional[str], backstory: Optional[str], blueprint_id: Optional[str], created_at: float, dataset_id: Optional[str], description: Optional[str], id: str, meta: Optional[Dict[str, Any]], model: Optional[str], moderation: Optional[bool], name: Optional[str], privacy: Optional[bool], skillset_id: Optional[str], updated_at: float, visibility: Optional[StickyVisibility]) -> None:
+        self.alias = alias
         self.backstory = backstory
         self.blueprint_id = blueprint_id
         self.created_at = created_at
@@ -3381,6 +3428,7 @@ def __init__(self, backstory: Optional[str], blueprint_id: Optional[str], create
     @staticmethod
     def from_dict(obj: Any) -> 'BotListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         backstory = from_union([from_str, from_none], obj.get("backstory"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
@@ -3395,10 +3443,12 @@ def from_dict(obj: Any) -> 'BotListStreamItemData':
         skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([StickyVisibility, from_none], obj.get("visibility"))
-        return BotListStreamItemData(backstory, blueprint_id, created_at, dataset_id, description, id, meta, model, moderation, name, privacy, skillset_id, updated_at, visibility)
+        return BotListStreamItemData(alias, backstory, blueprint_id, created_at, dataset_id, description, id, meta, model, moderation, name, privacy, skillset_id, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.backstory is not None:
             result["backstory"] = from_union([from_str, from_none], self.backstory)
         if self.blueprint_id is not None:
@@ -14476,6 +14526,9 @@ class DatasetFetchResponseVisibility(Enum):
 class DatasetFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -14527,7 +14580,8 @@ class DatasetFetchResponse:
     visibility: Optional[DatasetFetchResponseVisibility]
     """The dataset visibility"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, match_instruction: Optional[str], meta: Optional[Dict[str, Any]], mismatch_instruction: Optional[str], name: Optional[str], record_max_tokens: Optional[float], reranker: Optional[str], search_max_records: Optional[float], search_max_tokens: Optional[float], search_min_score: Optional[float], separators: Optional[str], store: str, updated_at: float, visibility: Optional[DatasetFetchResponseVisibility]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, match_instruction: Optional[str], meta: Optional[Dict[str, Any]], mismatch_instruction: Optional[str], name: Optional[str], record_max_tokens: Optional[float], reranker: Optional[str], search_max_records: Optional[float], search_max_tokens: Optional[float], search_min_score: Optional[float], separators: Optional[str], store: str, updated_at: float, visibility: Optional[DatasetFetchResponseVisibility]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.description = description
@@ -14549,6 +14603,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, description:
     @staticmethod
     def from_dict(obj: Any) -> 'DatasetFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -14566,10 +14621,12 @@ def from_dict(obj: Any) -> 'DatasetFetchResponse':
         store = from_str(obj.get("store"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([DatasetFetchResponseVisibility, from_none], obj.get("visibility"))
-        return DatasetFetchResponse(blueprint_id, created_at, description, id, match_instruction, meta, mismatch_instruction, name, record_max_tokens, reranker, search_max_records, search_max_tokens, search_min_score, separators, store, updated_at, visibility)
+        return DatasetFetchResponse(alias, blueprint_id, created_at, description, id, match_instruction, meta, mismatch_instruction, name, record_max_tokens, reranker, search_max_records, search_max_tokens, search_min_score, separators, store, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -14932,6 +14989,9 @@ class IndecentVisibility(Enum):
 class DatasetFileListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -14956,7 +15016,8 @@ class DatasetFileListStreamItemData:
     visibility: Optional[IndecentVisibility]
     """The file visibility"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[IndecentVisibility]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[IndecentVisibility]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.description = description
@@ -14969,6 +15030,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, description:
     @staticmethod
     def from_dict(obj: Any) -> 'DatasetFileListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -14977,10 +15039,12 @@ def from_dict(obj: Any) -> 'DatasetFileListStreamItemData':
         name = from_union([from_str, from_none], obj.get("name"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([IndecentVisibility, from_none], obj.get("visibility"))
-        return DatasetFileListStreamItemData(blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
+        return DatasetFileListStreamItemData(alias, blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -16172,6 +16236,9 @@ class HilariousVisibility(Enum):
 class DatasetListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -16223,7 +16290,8 @@ class DatasetListResponseItem:
     visibility: Optional[HilariousVisibility]
     """The dataset visibility"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, match_instruction: Optional[str], meta: Optional[Dict[str, Any]], mismatch_instruction: Optional[str], name: Optional[str], record_max_tokens: Optional[float], reranker: Optional[str], search_max_records: Optional[float], search_max_tokens: Optional[float], search_min_score: Optional[float], separators: Optional[str], store: str, updated_at: float, visibility: Optional[HilariousVisibility]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, match_instruction: Optional[str], meta: Optional[Dict[str, Any]], mismatch_instruction: Optional[str], name: Optional[str], record_max_tokens: Optional[float], reranker: Optional[str], search_max_records: Optional[float], search_max_tokens: Optional[float], search_min_score: Optional[float], separators: Optional[str], store: str, updated_at: float, visibility: Optional[HilariousVisibility]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.description = description
@@ -16245,6 +16313,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, description:
     @staticmethod
     def from_dict(obj: Any) -> 'DatasetListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -16262,10 +16331,12 @@ def from_dict(obj: Any) -> 'DatasetListResponseItem':
         store = from_str(obj.get("store"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([HilariousVisibility, from_none], obj.get("visibility"))
-        return DatasetListResponseItem(blueprint_id, created_at, description, id, match_instruction, meta, mismatch_instruction, name, record_max_tokens, reranker, search_max_records, search_max_tokens, search_min_score, separators, store, updated_at, visibility)
+        return DatasetListResponseItem(alias, blueprint_id, created_at, description, id, match_instruction, meta, mismatch_instruction, name, record_max_tokens, reranker, search_max_records, search_max_tokens, search_min_score, separators, store, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -16334,6 +16405,9 @@ class AmbitiousVisibility(Enum):
 class DatasetListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -16385,7 +16459,8 @@ class DatasetListStreamItemData:
     visibility: Optional[AmbitiousVisibility]
     """The dataset visibility"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, match_instruction: Optional[str], meta: Optional[Dict[str, Any]], mismatch_instruction: Optional[str], name: Optional[str], record_max_tokens: Optional[float], reranker: Optional[str], search_max_records: Optional[float], search_max_tokens: Optional[float], search_min_score: Optional[float], separators: Optional[str], store: str, updated_at: float, visibility: Optional[AmbitiousVisibility]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, match_instruction: Optional[str], meta: Optional[Dict[str, Any]], mismatch_instruction: Optional[str], name: Optional[str], record_max_tokens: Optional[float], reranker: Optional[str], search_max_records: Optional[float], search_max_tokens: Optional[float], search_min_score: Optional[float], separators: Optional[str], store: str, updated_at: float, visibility: Optional[AmbitiousVisibility]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.description = description
@@ -16407,6 +16482,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, description:
     @staticmethod
     def from_dict(obj: Any) -> 'DatasetListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -16424,10 +16500,12 @@ def from_dict(obj: Any) -> 'DatasetListStreamItemData':
         store = from_str(obj.get("store"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([AmbitiousVisibility, from_none], obj.get("visibility"))
-        return DatasetListStreamItemData(blueprint_id, created_at, description, id, match_instruction, meta, mismatch_instruction, name, record_max_tokens, reranker, search_max_records, search_max_tokens, search_min_score, separators, store, updated_at, visibility)
+        return DatasetListStreamItemData(alias, blueprint_id, created_at, description, id, match_instruction, meta, mismatch_instruction, name, record_max_tokens, reranker, search_max_records, search_max_tokens, search_min_score, separators, store, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -18176,6 +18254,9 @@ class FileFetchResponseVisibility(Enum):
 class FileFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -18200,7 +18281,8 @@ class FileFetchResponse:
     visibility: Optional[FileFetchResponseVisibility]
     """The file visibility"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[FileFetchResponseVisibility]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[FileFetchResponseVisibility]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.description = description
@@ -18213,6 +18295,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, description:
     @staticmethod
     def from_dict(obj: Any) -> 'FileFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -18221,10 +18304,12 @@ def from_dict(obj: Any) -> 'FileFetchResponse':
         name = from_union([from_str, from_none], obj.get("name"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([FileFetchResponseVisibility, from_none], obj.get("visibility"))
-        return FileFetchResponse(blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
+        return FileFetchResponse(alias, blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -18657,6 +18742,9 @@ class CunningVisibility(Enum):
 class FileListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -18681,7 +18769,8 @@ class FileListResponseItem:
     visibility: Optional[CunningVisibility]
     """The file visibility"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[CunningVisibility]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[CunningVisibility]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.description = description
@@ -18694,6 +18783,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, description:
     @staticmethod
     def from_dict(obj: Any) -> 'FileListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -18702,10 +18792,12 @@ def from_dict(obj: Any) -> 'FileListResponseItem':
         name = from_union([from_str, from_none], obj.get("name"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([CunningVisibility, from_none], obj.get("visibility"))
-        return FileListResponseItem(blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
+        return FileListResponseItem(alias, blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -18757,6 +18849,9 @@ class MagentaVisibility(Enum):
 class FileListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -18781,7 +18876,8 @@ class FileListStreamItemData:
     visibility: Optional[MagentaVisibility]
     """The file visibility"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[MagentaVisibility]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[MagentaVisibility]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.description = description
@@ -18794,6 +18890,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, description:
     @staticmethod
     def from_dict(obj: Any) -> 'FileListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -18802,10 +18899,12 @@ def from_dict(obj: Any) -> 'FileListStreamItemData':
         name = from_union([from_str, from_none], obj.get("name"))
         updated_at = from_float(obj.get("updatedAt"))
         visibility = from_union([MagentaVisibility, from_none], obj.get("visibility"))
-        return FileListStreamItemData(blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
+        return FileListStreamItemData(alias, blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -18913,6 +19012,9 @@ def to_dict(self) -> dict:
 class IntegrationDiscordFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """Restrict which Discord users can interact with this integration. Accepts Discord user IDs
     (17-18 digit snowflakes) or @username, one per line. Use * to allow all senders. Leave
@@ -18954,7 +19056,8 @@ class IntegrationDiscordFetchResponse:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], app_id: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], handle: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], app_id: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], handle: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.app_id = app_id
         self.blueprint_id = blueprint_id
@@ -18972,6 +19075,7 @@ def __init__(self, allow_from: Optional[str], app_id: Optional[str], blueprint_i
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationDiscordFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         app_id = from_union([from_str, from_none], obj.get("appId"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
@@ -18985,10 +19089,12 @@ def from_dict(obj: Any) -> 'IntegrationDiscordFetchResponse':
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationDiscordFetchResponse(allow_from, app_id, blueprint_id, bot_id, contact_collection, created_at, description, handle, id, meta, name, session_duration, updated_at)
+        return IntegrationDiscordFetchResponse(alias, allow_from, app_id, blueprint_id, bot_id, contact_collection, created_at, description, handle, id, meta, name, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.app_id is not None:
@@ -19075,6 +19181,9 @@ def to_dict(self) -> dict:
 class IntegrationDiscordUpdateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """Restrict which Discord users can interact with this integration. Accepts Discord user IDs
     (17-18 digit snowflakes) or @username, one per line. Use * to allow all senders. Leave
@@ -19113,7 +19222,8 @@ class IntegrationDiscordUpdateRequest:
     session_duration: Optional[float]
     """The chat session duration"""
 
-    def __init__(self, allow_from: Optional[str], app_id: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], description: Optional[str], handle: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], public_key: Optional[str], session_duration: Optional[float]) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], app_id: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], description: Optional[str], handle: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], public_key: Optional[str], session_duration: Optional[float]) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.app_id = app_id
         self.blueprint_id = blueprint_id
@@ -19130,6 +19240,7 @@ def __init__(self, allow_from: Optional[str], app_id: Optional[str], blueprint_i
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationDiscordUpdateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         app_id = from_union([from_str, from_none], obj.get("appId"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
@@ -19142,10 +19253,12 @@ def from_dict(obj: Any) -> 'IntegrationDiscordUpdateRequest':
         name = from_union([from_str, from_none], obj.get("name"))
         public_key = from_union([from_str, from_none], obj.get("publicKey"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return IntegrationDiscordUpdateRequest(allow_from, app_id, blueprint_id, bot_id, bot_token, contact_collection, description, handle, meta, name, public_key, session_duration)
+        return IntegrationDiscordUpdateRequest(alias, allow_from, app_id, blueprint_id, bot_id, bot_token, contact_collection, description, handle, meta, name, public_key, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.app_id is not None:
@@ -19195,6 +19308,9 @@ def to_dict(self) -> dict:
 class IntegrationDiscordCreateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """Restrict which Discord users can interact with this integration. Accepts Discord user IDs
     (17-18 digit snowflakes) or @username, one per line. Use * to allow all senders. Leave
@@ -19233,7 +19349,8 @@ class IntegrationDiscordCreateRequest:
     session_duration: Optional[float]
     """The chat session duration"""
 
-    def __init__(self, allow_from: Optional[str], app_id: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], description: Optional[str], handle: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], public_key: Optional[str], session_duration: Optional[float]) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], app_id: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], description: Optional[str], handle: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], public_key: Optional[str], session_duration: Optional[float]) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.app_id = app_id
         self.blueprint_id = blueprint_id
@@ -19250,6 +19367,7 @@ def __init__(self, allow_from: Optional[str], app_id: Optional[str], blueprint_i
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationDiscordCreateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         app_id = from_union([from_str, from_none], obj.get("appId"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
@@ -19262,10 +19380,12 @@ def from_dict(obj: Any) -> 'IntegrationDiscordCreateRequest':
         name = from_union([from_str, from_none], obj.get("name"))
         public_key = from_union([from_str, from_none], obj.get("publicKey"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return IntegrationDiscordCreateRequest(allow_from, app_id, blueprint_id, bot_id, bot_token, contact_collection, description, handle, meta, name, public_key, session_duration)
+        return IntegrationDiscordCreateRequest(alias, allow_from, app_id, blueprint_id, bot_id, bot_token, contact_collection, description, handle, meta, name, public_key, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.app_id is not None:
@@ -19363,6 +19483,9 @@ def to_dict(self) -> dict:
 class IntegrationDiscordListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """Restrict which Discord users can interact with this integration. Accepts Discord user IDs
     (17-18 digit snowflakes) or @username, one per line. Use * to allow all senders. Leave
@@ -19404,7 +19527,8 @@ class IntegrationDiscordListResponseItem:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], app_id: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], handle: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], app_id: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], handle: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.app_id = app_id
         self.blueprint_id = blueprint_id
@@ -19422,6 +19546,7 @@ def __init__(self, allow_from: Optional[str], app_id: Optional[str], blueprint_i
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationDiscordListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         app_id = from_union([from_str, from_none], obj.get("appId"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
@@ -19435,10 +19560,12 @@ def from_dict(obj: Any) -> 'IntegrationDiscordListResponseItem':
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationDiscordListResponseItem(allow_from, app_id, blueprint_id, bot_id, contact_collection, created_at, description, handle, id, meta, name, session_duration, updated_at)
+        return IntegrationDiscordListResponseItem(alias, allow_from, app_id, blueprint_id, bot_id, contact_collection, created_at, description, handle, id, meta, name, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.app_id is not None:
@@ -19492,6 +19619,9 @@ def to_dict(self) -> dict:
 class IntegrationDiscordListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """Restrict which Discord users can interact with this integration. Accepts Discord user IDs
     (17-18 digit snowflakes) or @username, one per line. Use * to allow all senders. Leave
@@ -19533,7 +19663,8 @@ class IntegrationDiscordListStreamItemData:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], app_id: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], handle: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], app_id: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], handle: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.app_id = app_id
         self.blueprint_id = blueprint_id
@@ -19551,6 +19682,7 @@ def __init__(self, allow_from: Optional[str], app_id: Optional[str], blueprint_i
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationDiscordListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         app_id = from_union([from_str, from_none], obj.get("appId"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
@@ -19564,10 +19696,12 @@ def from_dict(obj: Any) -> 'IntegrationDiscordListStreamItemData':
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationDiscordListStreamItemData(allow_from, app_id, blueprint_id, bot_id, contact_collection, created_at, description, handle, id, meta, name, session_duration, updated_at)
+        return IntegrationDiscordListStreamItemData(alias, allow_from, app_id, blueprint_id, bot_id, contact_collection, created_at, description, handle, id, meta, name, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.app_id is not None:
@@ -19685,6 +19819,9 @@ def to_dict(self) -> dict:
 class EmailIntegrationFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """Newline-separated list of email patterns allowed to send messages to this integration"""
 
@@ -19721,7 +19858,8 @@ class EmailIntegrationFetchResponse:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.attachments = attachments
         self.blueprint_id = blueprint_id
@@ -19738,6 +19876,7 @@ def __init__(self, allow_from: Optional[str], attachments: Optional[bool], bluep
     @staticmethod
     def from_dict(obj: Any) -> 'EmailIntegrationFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
@@ -19750,10 +19889,12 @@ def from_dict(obj: Any) -> 'EmailIntegrationFetchResponse':
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return EmailIntegrationFetchResponse(allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
+        return EmailIntegrationFetchResponse(alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
@@ -19838,6 +19979,9 @@ def to_dict(self) -> dict:
 class EmailIntegrationUpdateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """Newline-separated list of email patterns allowed to send messages to this integration"""
 
@@ -19865,7 +20009,8 @@ class EmailIntegrationUpdateRequest:
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.attachments = attachments
         self.blueprint_id = blueprint_id
@@ -19879,6 +20024,7 @@ def __init__(self, allow_from: Optional[str], attachments: Optional[bool], bluep
     @staticmethod
     def from_dict(obj: Any) -> 'EmailIntegrationUpdateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
@@ -19888,10 +20034,12 @@ def from_dict(obj: Any) -> 'EmailIntegrationUpdateRequest':
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return EmailIntegrationUpdateRequest(allow_from, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration)
+        return EmailIntegrationUpdateRequest(alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
@@ -19935,6 +20083,9 @@ def to_dict(self) -> dict:
 class EmailIntegrationCreateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """Newline-separated list of email patterns allowed to send messages to this integration"""
 
@@ -19962,7 +20113,8 @@ class EmailIntegrationCreateRequest:
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.attachments = attachments
         self.blueprint_id = blueprint_id
@@ -19976,6 +20128,7 @@ def __init__(self, allow_from: Optional[str], attachments: Optional[bool], bluep
     @staticmethod
     def from_dict(obj: Any) -> 'EmailIntegrationCreateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
@@ -19985,10 +20138,12 @@ def from_dict(obj: Any) -> 'EmailIntegrationCreateRequest':
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return EmailIntegrationCreateRequest(allow_from, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration)
+        return EmailIntegrationCreateRequest(alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
@@ -20080,6 +20235,9 @@ def to_dict(self) -> dict:
 class EmailIntegrationListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """Newline-separated list of email patterns allowed to send messages to this integration"""
 
@@ -20116,7 +20274,8 @@ class EmailIntegrationListResponseItem:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.attachments = attachments
         self.blueprint_id = blueprint_id
@@ -20133,6 +20292,7 @@ def __init__(self, allow_from: Optional[str], attachments: Optional[bool], bluep
     @staticmethod
     def from_dict(obj: Any) -> 'EmailIntegrationListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
@@ -20145,10 +20305,12 @@ def from_dict(obj: Any) -> 'EmailIntegrationListResponseItem':
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return EmailIntegrationListResponseItem(allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
+        return EmailIntegrationListResponseItem(alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
@@ -20200,6 +20362,9 @@ def to_dict(self) -> dict:
 class EmailIntegrationListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """Newline-separated list of email patterns allowed to send messages to this integration"""
 
@@ -20236,7 +20401,8 @@ class EmailIntegrationListStreamItemData:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.attachments = attachments
         self.blueprint_id = blueprint_id
@@ -20253,6 +20419,7 @@ def __init__(self, allow_from: Optional[str], attachments: Optional[bool], bluep
     @staticmethod
     def from_dict(obj: Any) -> 'EmailIntegrationListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
@@ -20265,10 +20432,12 @@ def from_dict(obj: Any) -> 'EmailIntegrationListStreamItemData':
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return EmailIntegrationListStreamItemData(allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
+        return EmailIntegrationListStreamItemData(alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
@@ -20384,6 +20553,9 @@ def to_dict(self) -> dict:
 class IntegrationExtractFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -20402,6 +20574,9 @@ class IntegrationExtractFetchResponse:
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
+    model: Optional[str]
+    """The language model to use for data extraction"""
+
     name: Optional[str]
     """The associated name"""
 
@@ -20414,13 +20589,15 @@ class IntegrationExtractFetchResponse:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: str, created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], request: Optional[str], schema: Optional[Dict[str, Any]], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: str, created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], model: Optional[str], name: Optional[str], request: Optional[str], schema: Optional[Dict[str, Any]], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
         self.created_at = created_at
         self.description = description
         self.id = id
         self.meta = meta
+        self.model = model
         self.name = name
         self.request = request
         self.schema = schema
@@ -20429,20 +20606,24 @@ def __init__(self, blueprint_id: Optional[str], bot_id: str, created_at: float,
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationExtractFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_str(obj.get("botId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        model = from_union([from_str, from_none], obj.get("model"))
         name = from_union([from_str, from_none], obj.get("name"))
         request = from_union([from_str, from_none], obj.get("request"))
         schema = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("schema"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationExtractFetchResponse(blueprint_id, bot_id, created_at, description, id, meta, name, request, schema, updated_at)
+        return IntegrationExtractFetchResponse(alias, blueprint_id, bot_id, created_at, description, id, meta, model, name, request, schema, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["botId"] = from_str(self.bot_id)
@@ -20452,6 +20633,8 @@ def to_dict(self) -> dict:
         result["id"] = from_str(self.id)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.model is not None:
+            result["model"] = from_union([from_str, from_none], self.model)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
         if self.request is not None:
@@ -20805,6 +20988,9 @@ def to_dict(self) -> dict:
 class IntegrationExtractUpdateRequest:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -20829,7 +21015,8 @@ class IntegrationExtractUpdateRequest:
     schema: Optional[Dict[str, Any]]
     """The configured extraction schema"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], model: Optional[str], name: Optional[str], request: Optional[str], schema: Optional[Dict[str, Any]]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], model: Optional[str], name: Optional[str], request: Optional[str], schema: Optional[Dict[str, Any]]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
         self.description = description
@@ -20842,6 +21029,7 @@ def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], descripti
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationExtractUpdateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -20850,10 +21038,12 @@ def from_dict(obj: Any) -> 'IntegrationExtractUpdateRequest':
         name = from_union([from_str, from_none], obj.get("name"))
         request = from_union([from_str, from_none], obj.get("request"))
         schema = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("schema"))
-        return IntegrationExtractUpdateRequest(blueprint_id, bot_id, description, meta, model, name, request, schema)
+        return IntegrationExtractUpdateRequest(alias, blueprint_id, bot_id, description, meta, model, name, request, schema)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
@@ -20895,6 +21085,9 @@ def to_dict(self) -> dict:
 class IntegrationExtractCreateRequest:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -20919,7 +21112,8 @@ class IntegrationExtractCreateRequest:
     schema: Optional[Dict[str, Any]]
     """The configured extraction schema"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], model: Optional[str], name: Optional[str], request: Optional[str], schema: Optional[Dict[str, Any]]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], model: Optional[str], name: Optional[str], request: Optional[str], schema: Optional[Dict[str, Any]]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
         self.description = description
@@ -20932,6 +21126,7 @@ def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], descripti
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationExtractCreateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -20940,10 +21135,12 @@ def from_dict(obj: Any) -> 'IntegrationExtractCreateRequest':
         name = from_union([from_str, from_none], obj.get("name"))
         request = from_union([from_str, from_none], obj.get("request"))
         schema = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("schema"))
-        return IntegrationExtractCreateRequest(blueprint_id, bot_id, description, meta, model, name, request, schema)
+        return IntegrationExtractCreateRequest(alias, blueprint_id, bot_id, description, meta, model, name, request, schema)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
@@ -21033,6 +21230,9 @@ def to_dict(self) -> dict:
 class IntegrationExtractListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -21051,6 +21251,9 @@ class IntegrationExtractListResponseItem:
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
+    model: Optional[str]
+    """The language model to use for data extraction"""
+
     name: Optional[str]
     """The associated name"""
 
@@ -21063,13 +21266,15 @@ class IntegrationExtractListResponseItem:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: str, created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], request: Optional[str], schema: Optional[Dict[str, Any]], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: str, created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], model: Optional[str], name: Optional[str], request: Optional[str], schema: Optional[Dict[str, Any]], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
         self.created_at = created_at
         self.description = description
         self.id = id
         self.meta = meta
+        self.model = model
         self.name = name
         self.request = request
         self.schema = schema
@@ -21078,20 +21283,24 @@ def __init__(self, blueprint_id: Optional[str], bot_id: str, created_at: float,
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationExtractListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_str(obj.get("botId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        model = from_union([from_str, from_none], obj.get("model"))
         name = from_union([from_str, from_none], obj.get("name"))
         request = from_union([from_str, from_none], obj.get("request"))
         schema = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("schema"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationExtractListResponseItem(blueprint_id, bot_id, created_at, description, id, meta, name, request, schema, updated_at)
+        return IntegrationExtractListResponseItem(alias, blueprint_id, bot_id, created_at, description, id, meta, model, name, request, schema, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["botId"] = from_str(self.bot_id)
@@ -21101,6 +21310,8 @@ def to_dict(self) -> dict:
         result["id"] = from_str(self.id)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.model is not None:
+            result["model"] = from_union([from_str, from_none], self.model)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
         if self.request is not None:
@@ -21138,6 +21349,9 @@ def to_dict(self) -> dict:
 class IntegrationExtractListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -21156,6 +21370,9 @@ class IntegrationExtractListStreamItemData:
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
+    model: Optional[str]
+    """The language model to use for data extraction"""
+
     name: Optional[str]
     """The associated name"""
 
@@ -21168,13 +21385,15 @@ class IntegrationExtractListStreamItemData:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: str, created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], request: Optional[str], schema: Optional[Dict[str, Any]], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: str, created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], model: Optional[str], name: Optional[str], request: Optional[str], schema: Optional[Dict[str, Any]], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
         self.created_at = created_at
         self.description = description
         self.id = id
         self.meta = meta
+        self.model = model
         self.name = name
         self.request = request
         self.schema = schema
@@ -21183,20 +21402,24 @@ def __init__(self, blueprint_id: Optional[str], bot_id: str, created_at: float,
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationExtractListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_str(obj.get("botId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        model = from_union([from_str, from_none], obj.get("model"))
         name = from_union([from_str, from_none], obj.get("name"))
         request = from_union([from_str, from_none], obj.get("request"))
         schema = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("schema"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationExtractListStreamItemData(blueprint_id, bot_id, created_at, description, id, meta, name, request, schema, updated_at)
+        return IntegrationExtractListStreamItemData(alias, blueprint_id, bot_id, created_at, description, id, meta, model, name, request, schema, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["botId"] = from_str(self.bot_id)
@@ -21206,6 +21429,8 @@ def to_dict(self) -> dict:
         result["id"] = from_str(self.id)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.model is not None:
+            result["model"] = from_union([from_str, from_none], self.model)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
         if self.request is not None:
@@ -21307,6 +21532,9 @@ def to_dict(self) -> dict:
 class GooglechatIntegrationFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """The allowed senders for this integration"""
 
@@ -21352,7 +21580,8 @@ class GooglechatIntegrationFetchResponse:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], project_number: Optional[str], service_account_key: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], project_number: Optional[str], service_account_key: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.attachments = attachments
         self.auto_respond = auto_respond
@@ -21372,6 +21601,7 @@ def __init__(self, allow_from: Optional[str], attachments: Optional[bool], auto_
     @staticmethod
     def from_dict(obj: Any) -> 'GooglechatIntegrationFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
@@ -21387,10 +21617,12 @@ def from_dict(obj: Any) -> 'GooglechatIntegrationFetchResponse':
         service_account_key = from_union([from_str, from_none], obj.get("serviceAccountKey"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return GooglechatIntegrationFetchResponse(allow_from, attachments, auto_respond, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, project_number, service_account_key, session_duration, updated_at)
+        return GooglechatIntegrationFetchResponse(alias, allow_from, attachments, auto_respond, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, project_number, service_account_key, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
@@ -21481,6 +21713,9 @@ def to_dict(self) -> dict:
 class GooglechatIntegrationUpdateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """The allowed senders for this integration"""
 
@@ -21517,7 +21752,8 @@ class GooglechatIntegrationUpdateRequest:
     session_duration: Optional[float]
     """The session duration for the integration"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], project_number: Optional[str], service_account_key: Optional[str], session_duration: Optional[float]) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], project_number: Optional[str], service_account_key: Optional[str], session_duration: Optional[float]) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.attachments = attachments
         self.auto_respond = auto_respond
@@ -21534,6 +21770,7 @@ def __init__(self, allow_from: Optional[str], attachments: Optional[bool], auto_
     @staticmethod
     def from_dict(obj: Any) -> 'GooglechatIntegrationUpdateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
@@ -21546,10 +21783,12 @@ def from_dict(obj: Any) -> 'GooglechatIntegrationUpdateRequest':
         project_number = from_union([from_str, from_none], obj.get("projectNumber"))
         service_account_key = from_union([from_str, from_none], obj.get("serviceAccountKey"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return GooglechatIntegrationUpdateRequest(allow_from, attachments, auto_respond, blueprint_id, bot_id, contact_collection, description, meta, name, project_number, service_account_key, session_duration)
+        return GooglechatIntegrationUpdateRequest(alias, allow_from, attachments, auto_respond, blueprint_id, bot_id, contact_collection, description, meta, name, project_number, service_account_key, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
@@ -21599,6 +21838,9 @@ def to_dict(self) -> dict:
 class GooglechatIntegrationCreateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """Restrict which Google Chat users can interact with this integration. Accepts user
     resource names (users/USER_ID) or * to allow all. One per line.
@@ -21638,7 +21880,8 @@ class GooglechatIntegrationCreateRequest:
     session_duration: Optional[float]
     """The session duration for the Google Chat integration"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], project_number: Optional[str], service_account_key: Optional[str], session_duration: Optional[float]) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], project_number: Optional[str], service_account_key: Optional[str], session_duration: Optional[float]) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.attachments = attachments
         self.auto_respond = auto_respond
@@ -21655,6 +21898,7 @@ def __init__(self, allow_from: Optional[str], attachments: Optional[bool], auto_
     @staticmethod
     def from_dict(obj: Any) -> 'GooglechatIntegrationCreateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
@@ -21667,10 +21911,12 @@ def from_dict(obj: Any) -> 'GooglechatIntegrationCreateRequest':
         project_number = from_union([from_str, from_none], obj.get("projectNumber"))
         service_account_key = from_union([from_str, from_none], obj.get("serviceAccountKey"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return GooglechatIntegrationCreateRequest(allow_from, attachments, auto_respond, blueprint_id, bot_id, contact_collection, description, meta, name, project_number, service_account_key, session_duration)
+        return GooglechatIntegrationCreateRequest(alias, allow_from, attachments, auto_respond, blueprint_id, bot_id, contact_collection, description, meta, name, project_number, service_account_key, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
@@ -21768,6 +22014,9 @@ def to_dict(self) -> dict:
 class GooglechatIntegrationListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """The allowed senders for this integration"""
 
@@ -21813,7 +22062,8 @@ class GooglechatIntegrationListResponseItem:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], project_number: Optional[str], service_account_key: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], project_number: Optional[str], service_account_key: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.attachments = attachments
         self.auto_respond = auto_respond
@@ -21833,6 +22083,7 @@ def __init__(self, allow_from: Optional[str], attachments: Optional[bool], auto_
     @staticmethod
     def from_dict(obj: Any) -> 'GooglechatIntegrationListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
@@ -21848,10 +22099,12 @@ def from_dict(obj: Any) -> 'GooglechatIntegrationListResponseItem':
         service_account_key = from_union([from_str, from_none], obj.get("serviceAccountKey"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return GooglechatIntegrationListResponseItem(allow_from, attachments, auto_respond, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, project_number, service_account_key, session_duration, updated_at)
+        return GooglechatIntegrationListResponseItem(alias, allow_from, attachments, auto_respond, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, project_number, service_account_key, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
@@ -21909,6 +22162,9 @@ def to_dict(self) -> dict:
 class GooglechatIntegrationListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """The allowed senders for this integration"""
 
@@ -21954,7 +22210,8 @@ class GooglechatIntegrationListStreamItemData:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], project_number: Optional[str], service_account_key: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], project_number: Optional[str], service_account_key: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.attachments = attachments
         self.auto_respond = auto_respond
@@ -21974,6 +22231,7 @@ def __init__(self, allow_from: Optional[str], attachments: Optional[bool], auto_
     @staticmethod
     def from_dict(obj: Any) -> 'GooglechatIntegrationListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
@@ -21989,10 +22247,12 @@ def from_dict(obj: Any) -> 'GooglechatIntegrationListStreamItemData':
         service_account_key = from_union([from_str, from_none], obj.get("serviceAccountKey"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return GooglechatIntegrationListStreamItemData(allow_from, attachments, auto_respond, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, project_number, service_account_key, session_duration, updated_at)
+        return GooglechatIntegrationListStreamItemData(alias, allow_from, attachments, auto_respond, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, project_number, service_account_key, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
@@ -22118,6 +22378,9 @@ class IntegrationInstagramFetchResponse:
     """The Instagram integration access token (returned as '********' if configured, null
     otherwise)
     """
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     attachments: Optional[bool]
     """Whether the bot supports attachments"""
 
@@ -22154,8 +22417,9 @@ class IntegrationInstagramFetchResponse:
     verify_token: str
     """The Instagram integration verify token"""
 
-    def __init__(self, access_token: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
         self.access_token = access_token
+        self.alias = alias
         self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
@@ -22173,6 +22437,7 @@ def __init__(self, access_token: Optional[str], attachments: Optional[bool], blu
     def from_dict(obj: Any) -> 'IntegrationInstagramFetchResponse':
         assert isinstance(obj, dict)
         access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
@@ -22185,12 +22450,14 @@ def from_dict(obj: Any) -> 'IntegrationInstagramFetchResponse':
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
         verify_token = from_str(obj.get("verifyToken"))
-        return IntegrationInstagramFetchResponse(access_token, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, verify_token)
+        return IntegrationInstagramFetchResponse(access_token, alias, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, verify_token)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.access_token is not None:
             result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
@@ -22277,6 +22544,9 @@ class IntegrationInstagramUpdateRequest:
     access_token: Optional[str]
     """The Instagram integration access token"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     attachments: Optional[bool]
     """Whether the bot supports attachments"""
 
@@ -22301,8 +22571,9 @@ class IntegrationInstagramUpdateRequest:
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    def __init__(self, access_token: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
         self.access_token = access_token
+        self.alias = alias
         self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
@@ -22316,6 +22587,7 @@ def __init__(self, access_token: Optional[str], attachments: Optional[bool], blu
     def from_dict(obj: Any) -> 'IntegrationInstagramUpdateRequest':
         assert isinstance(obj, dict)
         access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
@@ -22324,12 +22596,14 @@ def from_dict(obj: Any) -> 'IntegrationInstagramUpdateRequest':
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return IntegrationInstagramUpdateRequest(access_token, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration)
+        return IntegrationInstagramUpdateRequest(access_token, alias, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.access_token is not None:
             result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
@@ -22374,6 +22648,9 @@ class IntegrationInstagramCreateRequest:
     access_token: Optional[str]
     """The Instagram integration access token"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     attachments: Optional[bool]
     """Whether the bot supports attachments"""
 
@@ -22398,8 +22675,9 @@ class IntegrationInstagramCreateRequest:
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    def __init__(self, access_token: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
         self.access_token = access_token
+        self.alias = alias
         self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
@@ -22413,6 +22691,7 @@ def __init__(self, access_token: Optional[str], attachments: Optional[bool], blu
     def from_dict(obj: Any) -> 'IntegrationInstagramCreateRequest':
         assert isinstance(obj, dict)
         access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
@@ -22421,12 +22700,14 @@ def from_dict(obj: Any) -> 'IntegrationInstagramCreateRequest':
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return IntegrationInstagramCreateRequest(access_token, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration)
+        return IntegrationInstagramCreateRequest(access_token, alias, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.access_token is not None:
             result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
@@ -22520,6 +22801,9 @@ class IntegrationInstagramListResponseItem:
     """The Instagram integration access token (returned as '********' if configured, null
     otherwise)
     """
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     attachments: Optional[bool]
     """Whether the bot supports attachments"""
 
@@ -22556,8 +22840,9 @@ class IntegrationInstagramListResponseItem:
     verify_token: str
     """The Instagram integration verify token"""
 
-    def __init__(self, access_token: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
         self.access_token = access_token
+        self.alias = alias
         self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
@@ -22575,6 +22860,7 @@ def __init__(self, access_token: Optional[str], attachments: Optional[bool], blu
     def from_dict(obj: Any) -> 'IntegrationInstagramListResponseItem':
         assert isinstance(obj, dict)
         access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
@@ -22587,12 +22873,14 @@ def from_dict(obj: Any) -> 'IntegrationInstagramListResponseItem':
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
         verify_token = from_str(obj.get("verifyToken"))
-        return IntegrationInstagramListResponseItem(access_token, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, verify_token)
+        return IntegrationInstagramListResponseItem(access_token, alias, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, verify_token)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.access_token is not None:
             result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
@@ -22647,6 +22935,9 @@ class IntegrationInstagramListStreamItemData:
     """The Instagram integration access token (returned as '********' if configured, null
     otherwise)
     """
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     attachments: Optional[bool]
     """Whether the bot supports attachments"""
 
@@ -22683,8 +22974,9 @@ class IntegrationInstagramListStreamItemData:
     verify_token: str
     """The Instagram integration verify token"""
 
-    def __init__(self, access_token: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
         self.access_token = access_token
+        self.alias = alias
         self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
@@ -22702,6 +22994,7 @@ def __init__(self, access_token: Optional[str], attachments: Optional[bool], blu
     def from_dict(obj: Any) -> 'IntegrationInstagramListStreamItemData':
         assert isinstance(obj, dict)
         access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
@@ -22714,12 +23007,14 @@ def from_dict(obj: Any) -> 'IntegrationInstagramListStreamItemData':
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
         verify_token = from_str(obj.get("verifyToken"))
-        return IntegrationInstagramListStreamItemData(access_token, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, verify_token)
+        return IntegrationInstagramListStreamItemData(access_token, alias, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, verify_token)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.access_token is not None:
             result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
@@ -22834,6 +23129,9 @@ def to_dict(self) -> dict:
 class IntegrationMCPServerFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -22861,7 +23159,8 @@ class IntegrationMCPServerFetchResponse:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], o_auth_connection_id: Optional[str], skillset_id: Optional[str], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], o_auth_connection_id: Optional[str], skillset_id: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.description = description
@@ -22875,6 +23174,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, description:
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationMCPServerFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -22884,10 +23184,12 @@ def from_dict(obj: Any) -> 'IntegrationMCPServerFetchResponse':
         o_auth_connection_id = from_union([from_str, from_none], obj.get("oAuthConnectionId"))
         skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationMCPServerFetchResponse(blueprint_id, created_at, description, id, meta, name, o_auth_connection_id, skillset_id, updated_at)
+        return IntegrationMCPServerFetchResponse(alias, blueprint_id, created_at, description, id, meta, name, o_auth_connection_id, skillset_id, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -22928,6 +23230,9 @@ def to_dict(self) -> dict:
 class IntegrationMCPServerUpdateRequest:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -22946,7 +23251,8 @@ class IntegrationMCPServerUpdateRequest:
     skillset_id: Optional[str]
     """The ID of the skillset"""
 
-    def __init__(self, blueprint_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], o_auth_connection_id: Optional[str], skillset_id: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], o_auth_connection_id: Optional[str], skillset_id: Optional[str]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.description = description
         self.meta = meta
@@ -22957,16 +23263,19 @@ def __init__(self, blueprint_id: Optional[str], description: Optional[str], meta
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationMCPServerUpdateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         description = from_union([from_str, from_none], obj.get("description"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
         o_auth_connection_id = from_union([from_str, from_none], obj.get("oAuthConnectionId"))
         skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
-        return IntegrationMCPServerUpdateRequest(blueprint_id, description, meta, name, o_auth_connection_id, skillset_id)
+        return IntegrationMCPServerUpdateRequest(alias, blueprint_id, description, meta, name, o_auth_connection_id, skillset_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.description is not None:
@@ -23004,6 +23313,9 @@ def to_dict(self) -> dict:
 class IntegrationMCPServerCreateRequest:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -23022,7 +23334,8 @@ class IntegrationMCPServerCreateRequest:
     skillset_id: Optional[str]
     """The ID of the skillset"""
 
-    def __init__(self, blueprint_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], o_auth_connection_id: Optional[str], skillset_id: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], o_auth_connection_id: Optional[str], skillset_id: Optional[str]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.description = description
         self.meta = meta
@@ -23033,16 +23346,19 @@ def __init__(self, blueprint_id: Optional[str], description: Optional[str], meta
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationMCPServerCreateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         description = from_union([from_str, from_none], obj.get("description"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
         o_auth_connection_id = from_union([from_str, from_none], obj.get("oAuthConnectionId"))
         skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
-        return IntegrationMCPServerCreateRequest(blueprint_id, description, meta, name, o_auth_connection_id, skillset_id)
+        return IntegrationMCPServerCreateRequest(alias, blueprint_id, description, meta, name, o_auth_connection_id, skillset_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.description is not None:
@@ -23128,6 +23444,9 @@ def to_dict(self) -> dict:
 class IntegrationMCPServerListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -23155,7 +23474,8 @@ class IntegrationMCPServerListResponseItem:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], o_auth_connection_id: Optional[str], skillset_id: Optional[str], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], o_auth_connection_id: Optional[str], skillset_id: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.description = description
@@ -23169,6 +23489,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, description:
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationMCPServerListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -23178,10 +23499,12 @@ def from_dict(obj: Any) -> 'IntegrationMCPServerListResponseItem':
         o_auth_connection_id = from_union([from_str, from_none], obj.get("oAuthConnectionId"))
         skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationMCPServerListResponseItem(blueprint_id, created_at, description, id, meta, name, o_auth_connection_id, skillset_id, updated_at)
+        return IntegrationMCPServerListResponseItem(alias, blueprint_id, created_at, description, id, meta, name, o_auth_connection_id, skillset_id, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -23227,6 +23550,9 @@ def to_dict(self) -> dict:
 class IntegrationMCPServerListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -23254,7 +23580,8 @@ class IntegrationMCPServerListStreamItemData:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], o_auth_connection_id: Optional[str], skillset_id: Optional[str], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], o_auth_connection_id: Optional[str], skillset_id: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.description = description
@@ -23268,6 +23595,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, description:
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationMCPServerListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -23277,10 +23605,12 @@ def from_dict(obj: Any) -> 'IntegrationMCPServerListStreamItemData':
         o_auth_connection_id = from_union([from_str, from_none], obj.get("oAuthConnectionId"))
         skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationMCPServerListStreamItemData(blueprint_id, created_at, description, id, meta, name, o_auth_connection_id, skillset_id, updated_at)
+        return IntegrationMCPServerListStreamItemData(alias, blueprint_id, created_at, description, id, meta, name, o_auth_connection_id, skillset_id, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -23394,6 +23724,9 @@ class IntegrationMessengerFetchResponse:
     """The Messenger integration access token (returned as '********' if configured, null
     otherwise)
     """
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     attachments: Optional[bool]
     """Whether the bot supports attachments"""
 
@@ -23430,8 +23763,9 @@ class IntegrationMessengerFetchResponse:
     verify_token: str
     """The Messenger integration verify token"""
 
-    def __init__(self, access_token: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
         self.access_token = access_token
+        self.alias = alias
         self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
@@ -23449,6 +23783,7 @@ def __init__(self, access_token: Optional[str], attachments: Optional[bool], blu
     def from_dict(obj: Any) -> 'IntegrationMessengerFetchResponse':
         assert isinstance(obj, dict)
         access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
@@ -23461,12 +23796,14 @@ def from_dict(obj: Any) -> 'IntegrationMessengerFetchResponse':
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
         verify_token = from_str(obj.get("verifyToken"))
-        return IntegrationMessengerFetchResponse(access_token, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, verify_token)
+        return IntegrationMessengerFetchResponse(access_token, alias, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, verify_token)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.access_token is not None:
             result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
@@ -23553,6 +23890,9 @@ class IntegrationMessengerUpdateRequest:
     access_token: Optional[str]
     """The Messenger integration access token"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     attachments: Optional[bool]
     """Whether the bot supports attachments"""
 
@@ -23577,8 +23917,9 @@ class IntegrationMessengerUpdateRequest:
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    def __init__(self, access_token: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
         self.access_token = access_token
+        self.alias = alias
         self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
@@ -23592,6 +23933,7 @@ def __init__(self, access_token: Optional[str], attachments: Optional[bool], blu
     def from_dict(obj: Any) -> 'IntegrationMessengerUpdateRequest':
         assert isinstance(obj, dict)
         access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
@@ -23600,12 +23942,14 @@ def from_dict(obj: Any) -> 'IntegrationMessengerUpdateRequest':
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return IntegrationMessengerUpdateRequest(access_token, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration)
+        return IntegrationMessengerUpdateRequest(access_token, alias, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.access_token is not None:
             result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
@@ -23650,6 +23994,9 @@ class IntegrationMessengerCreateRequest:
     access_token: Optional[str]
     """The Messenger integration access token"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     attachments: Optional[bool]
     """Whether the bot supports attachments"""
 
@@ -23674,8 +24021,9 @@ class IntegrationMessengerCreateRequest:
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    def __init__(self, access_token: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
         self.access_token = access_token
+        self.alias = alias
         self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
@@ -23689,6 +24037,7 @@ def __init__(self, access_token: Optional[str], attachments: Optional[bool], blu
     def from_dict(obj: Any) -> 'IntegrationMessengerCreateRequest':
         assert isinstance(obj, dict)
         access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
@@ -23697,12 +24046,14 @@ def from_dict(obj: Any) -> 'IntegrationMessengerCreateRequest':
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return IntegrationMessengerCreateRequest(access_token, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration)
+        return IntegrationMessengerCreateRequest(access_token, alias, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.access_token is not None:
             result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
@@ -23796,6 +24147,9 @@ class IntegrationMessengerListResponseItem:
     """The Messenger integration access token (returned as '********' if configured, null
     otherwise)
     """
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     attachments: Optional[bool]
     """Whether the bot supports attachments"""
 
@@ -23832,8 +24186,9 @@ class IntegrationMessengerListResponseItem:
     verify_token: str
     """The Messenger integration verify token"""
 
-    def __init__(self, access_token: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
         self.access_token = access_token
+        self.alias = alias
         self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
@@ -23851,6 +24206,7 @@ def __init__(self, access_token: Optional[str], attachments: Optional[bool], blu
     def from_dict(obj: Any) -> 'IntegrationMessengerListResponseItem':
         assert isinstance(obj, dict)
         access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
@@ -23863,12 +24219,14 @@ def from_dict(obj: Any) -> 'IntegrationMessengerListResponseItem':
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
         verify_token = from_str(obj.get("verifyToken"))
-        return IntegrationMessengerListResponseItem(access_token, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, verify_token)
+        return IntegrationMessengerListResponseItem(access_token, alias, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, verify_token)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.access_token is not None:
             result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
@@ -23923,6 +24281,9 @@ class IntegrationMessengerListStreamItemData:
     """The Messenger integration access token (returned as '********' if configured, null
     otherwise)
     """
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     attachments: Optional[bool]
     """Whether the bot supports attachments"""
 
@@ -23959,8 +24320,9 @@ class IntegrationMessengerListStreamItemData:
     verify_token: str
     """The Messenger integration verify token"""
 
-    def __init__(self, access_token: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
         self.access_token = access_token
+        self.alias = alias
         self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
@@ -23978,6 +24340,7 @@ def __init__(self, access_token: Optional[str], attachments: Optional[bool], blu
     def from_dict(obj: Any) -> 'IntegrationMessengerListStreamItemData':
         assert isinstance(obj, dict)
         access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
@@ -23990,12 +24353,14 @@ def from_dict(obj: Any) -> 'IntegrationMessengerListStreamItemData':
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
         verify_token = from_str(obj.get("verifyToken"))
-        return IntegrationMessengerListStreamItemData(access_token, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, verify_token)
+        return IntegrationMessengerListStreamItemData(access_token, alias, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, verify_token)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.access_token is not None:
             result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
@@ -24110,6 +24475,9 @@ def to_dict(self) -> dict:
 class MicrosoftteamsIntegrationFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """The allowed senders for this integration"""
 
@@ -24146,7 +24514,8 @@ class MicrosoftteamsIntegrationFetchResponse:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], blueprint_id: Optional[str], bot_framework_app_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], blueprint_id: Optional[str], bot_framework_app_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.blueprint_id = blueprint_id
         self.bot_framework_app_id = bot_framework_app_id
@@ -24163,6 +24532,7 @@ def __init__(self, allow_from: Optional[str], blueprint_id: Optional[str], bot_f
     @staticmethod
     def from_dict(obj: Any) -> 'MicrosoftteamsIntegrationFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_framework_app_id = from_union([from_str, from_none], obj.get("botFrameworkAppId"))
@@ -24175,10 +24545,12 @@ def from_dict(obj: Any) -> 'MicrosoftteamsIntegrationFetchResponse':
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return MicrosoftteamsIntegrationFetchResponse(allow_from, blueprint_id, bot_framework_app_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
+        return MicrosoftteamsIntegrationFetchResponse(alias, allow_from, blueprint_id, bot_framework_app_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.blueprint_id is not None:
@@ -24263,6 +24635,9 @@ def to_dict(self) -> dict:
 class MicrosoftteamsIntegrationUpdateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """The allowed senders for this integration"""
 
@@ -24296,7 +24671,8 @@ class MicrosoftteamsIntegrationUpdateRequest:
     tenant_id: Optional[str]
     """The Microsoft Entra tenant ID"""
 
-    def __init__(self, allow_from: Optional[str], blueprint_id: Optional[str], bot_framework_app_id: Optional[str], bot_framework_app_secret: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], tenant_id: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], blueprint_id: Optional[str], bot_framework_app_id: Optional[str], bot_framework_app_secret: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], tenant_id: Optional[str]) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.blueprint_id = blueprint_id
         self.bot_framework_app_id = bot_framework_app_id
@@ -24312,6 +24688,7 @@ def __init__(self, allow_from: Optional[str], blueprint_id: Optional[str], bot_f
     @staticmethod
     def from_dict(obj: Any) -> 'MicrosoftteamsIntegrationUpdateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_framework_app_id = from_union([from_str, from_none], obj.get("botFrameworkAppId"))
@@ -24323,10 +24700,12 @@ def from_dict(obj: Any) -> 'MicrosoftteamsIntegrationUpdateRequest':
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         tenant_id = from_union([from_str, from_none], obj.get("tenantId"))
-        return MicrosoftteamsIntegrationUpdateRequest(allow_from, blueprint_id, bot_framework_app_id, bot_framework_app_secret, bot_id, contact_collection, description, meta, name, session_duration, tenant_id)
+        return MicrosoftteamsIntegrationUpdateRequest(alias, allow_from, blueprint_id, bot_framework_app_id, bot_framework_app_secret, bot_id, contact_collection, description, meta, name, session_duration, tenant_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.blueprint_id is not None:
@@ -24374,6 +24753,9 @@ def to_dict(self) -> dict:
 class MicrosoftteamsIntegrationCreateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """The allowed senders for this integration"""
 
@@ -24407,7 +24789,8 @@ class MicrosoftteamsIntegrationCreateRequest:
     tenant_id: Optional[str]
     """The Microsoft Entra tenant ID"""
 
-    def __init__(self, allow_from: Optional[str], blueprint_id: Optional[str], bot_framework_app_id: Optional[str], bot_framework_app_secret: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], tenant_id: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], blueprint_id: Optional[str], bot_framework_app_id: Optional[str], bot_framework_app_secret: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], tenant_id: Optional[str]) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.blueprint_id = blueprint_id
         self.bot_framework_app_id = bot_framework_app_id
@@ -24423,6 +24806,7 @@ def __init__(self, allow_from: Optional[str], blueprint_id: Optional[str], bot_f
     @staticmethod
     def from_dict(obj: Any) -> 'MicrosoftteamsIntegrationCreateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_framework_app_id = from_union([from_str, from_none], obj.get("botFrameworkAppId"))
@@ -24434,10 +24818,12 @@ def from_dict(obj: Any) -> 'MicrosoftteamsIntegrationCreateRequest':
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         tenant_id = from_union([from_str, from_none], obj.get("tenantId"))
-        return MicrosoftteamsIntegrationCreateRequest(allow_from, blueprint_id, bot_framework_app_id, bot_framework_app_secret, bot_id, contact_collection, description, meta, name, session_duration, tenant_id)
+        return MicrosoftteamsIntegrationCreateRequest(alias, allow_from, blueprint_id, bot_framework_app_id, bot_framework_app_secret, bot_id, contact_collection, description, meta, name, session_duration, tenant_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.blueprint_id is not None:
@@ -24533,6 +24919,9 @@ def to_dict(self) -> dict:
 class MicrosoftteamsIntegrationListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """The allowed senders for this integration"""
 
@@ -24569,7 +24958,8 @@ class MicrosoftteamsIntegrationListResponseItem:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], blueprint_id: Optional[str], bot_framework_app_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], blueprint_id: Optional[str], bot_framework_app_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.blueprint_id = blueprint_id
         self.bot_framework_app_id = bot_framework_app_id
@@ -24586,6 +24976,7 @@ def __init__(self, allow_from: Optional[str], blueprint_id: Optional[str], bot_f
     @staticmethod
     def from_dict(obj: Any) -> 'MicrosoftteamsIntegrationListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_framework_app_id = from_union([from_str, from_none], obj.get("botFrameworkAppId"))
@@ -24598,10 +24989,12 @@ def from_dict(obj: Any) -> 'MicrosoftteamsIntegrationListResponseItem':
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return MicrosoftteamsIntegrationListResponseItem(allow_from, blueprint_id, bot_framework_app_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
+        return MicrosoftteamsIntegrationListResponseItem(alias, allow_from, blueprint_id, bot_framework_app_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.blueprint_id is not None:
@@ -24653,6 +25046,9 @@ def to_dict(self) -> dict:
 class MicrosoftteamsIntegrationListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """The allowed senders for this integration"""
 
@@ -24689,7 +25085,8 @@ class MicrosoftteamsIntegrationListStreamItemData:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], blueprint_id: Optional[str], bot_framework_app_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], blueprint_id: Optional[str], bot_framework_app_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
         self.allow_from = allow_from
         self.blueprint_id = blueprint_id
         self.bot_framework_app_id = bot_framework_app_id
@@ -24706,6 +25103,7 @@ def __init__(self, allow_from: Optional[str], blueprint_id: Optional[str], bot_f
     @staticmethod
     def from_dict(obj: Any) -> 'MicrosoftteamsIntegrationListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_framework_app_id = from_union([from_str, from_none], obj.get("botFrameworkAppId"))
@@ -24718,10 +25116,12 @@ def from_dict(obj: Any) -> 'MicrosoftteamsIntegrationListStreamItemData':
         name = from_union([from_str, from_none], obj.get("name"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return MicrosoftteamsIntegrationListStreamItemData(allow_from, blueprint_id, bot_framework_app_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
+        return MicrosoftteamsIntegrationListStreamItemData(alias, allow_from, blueprint_id, bot_framework_app_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.blueprint_id is not None:
@@ -24845,6 +25245,9 @@ class IntegrationNotionFetchResponseSyncStatus(Enum):
 class IntegrationNotionFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -24884,7 +25287,8 @@ class IntegrationNotionFetchResponse:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, dataset_id: str, description: Optional[str], expires_in: Optional[float], id: str, last_synced_at: Optional[datetime], meta: Optional[Dict[str, Any]], name: Optional[str], sync_schedule: Optional[str], sync_status: Optional[IntegrationNotionFetchResponseSyncStatus], token: Optional[str], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, dataset_id: str, description: Optional[str], expires_in: Optional[float], id: str, last_synced_at: Optional[datetime], meta: Optional[Dict[str, Any]], name: Optional[str], sync_schedule: Optional[str], sync_status: Optional[IntegrationNotionFetchResponseSyncStatus], token: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.dataset_id = dataset_id
@@ -24902,6 +25306,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, dataset_id: s
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationNotionFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         dataset_id = from_str(obj.get("datasetId"))
@@ -24915,10 +25320,12 @@ def from_dict(obj: Any) -> 'IntegrationNotionFetchResponse':
         sync_status = from_union([IntegrationNotionFetchResponseSyncStatus, from_none], obj.get("syncStatus"))
         token = from_union([from_str, from_none], obj.get("token"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationNotionFetchResponse(blueprint_id, created_at, dataset_id, description, expires_in, id, last_synced_at, meta, name, sync_schedule, sync_status, token, updated_at)
+        return IntegrationNotionFetchResponse(alias, blueprint_id, created_at, dataset_id, description, expires_in, id, last_synced_at, meta, name, sync_schedule, sync_status, token, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -25004,6 +25411,9 @@ def to_dict(self) -> dict:
 class IntegrationNotionUpdateRequest:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -25028,7 +25438,8 @@ class IntegrationNotionUpdateRequest:
     token: Optional[str]
     """The Notion API token"""
 
-    def __init__(self, blueprint_id: Optional[str], dataset_id: Optional[str], description: Optional[str], expires_in: Optional[float], meta: Optional[Dict[str, Any]], name: Optional[str], sync_schedule: Optional[str], token: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], dataset_id: Optional[str], description: Optional[str], expires_in: Optional[float], meta: Optional[Dict[str, Any]], name: Optional[str], sync_schedule: Optional[str], token: Optional[str]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.dataset_id = dataset_id
         self.description = description
@@ -25041,6 +25452,7 @@ def __init__(self, blueprint_id: Optional[str], dataset_id: Optional[str], descr
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationNotionUpdateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         dataset_id = from_union([from_str, from_none], obj.get("datasetId"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -25049,10 +25461,12 @@ def from_dict(obj: Any) -> 'IntegrationNotionUpdateRequest':
         name = from_union([from_str, from_none], obj.get("name"))
         sync_schedule = from_union([from_str, from_none], obj.get("syncSchedule"))
         token = from_union([from_str, from_none], obj.get("token"))
-        return IntegrationNotionUpdateRequest(blueprint_id, dataset_id, description, expires_in, meta, name, sync_schedule, token)
+        return IntegrationNotionUpdateRequest(alias, blueprint_id, dataset_id, description, expires_in, meta, name, sync_schedule, token)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.dataset_id is not None:
@@ -25094,6 +25508,9 @@ def to_dict(self) -> dict:
 class IntegrationNotionCreateRequest:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -25118,7 +25535,8 @@ class IntegrationNotionCreateRequest:
     token: Optional[str]
     """The Notion API token"""
 
-    def __init__(self, blueprint_id: Optional[str], dataset_id: Optional[str], description: Optional[str], expires_in: Optional[float], meta: Optional[Dict[str, Any]], name: Optional[str], sync_schedule: Optional[str], token: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], dataset_id: Optional[str], description: Optional[str], expires_in: Optional[float], meta: Optional[Dict[str, Any]], name: Optional[str], sync_schedule: Optional[str], token: Optional[str]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.dataset_id = dataset_id
         self.description = description
@@ -25131,6 +25549,7 @@ def __init__(self, blueprint_id: Optional[str], dataset_id: Optional[str], descr
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationNotionCreateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         dataset_id = from_union([from_str, from_none], obj.get("datasetId"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -25139,10 +25558,12 @@ def from_dict(obj: Any) -> 'IntegrationNotionCreateRequest':
         name = from_union([from_str, from_none], obj.get("name"))
         sync_schedule = from_union([from_str, from_none], obj.get("syncSchedule"))
         token = from_union([from_str, from_none], obj.get("token"))
-        return IntegrationNotionCreateRequest(blueprint_id, dataset_id, description, expires_in, meta, name, sync_schedule, token)
+        return IntegrationNotionCreateRequest(alias, blueprint_id, dataset_id, description, expires_in, meta, name, sync_schedule, token)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.dataset_id is not None:
@@ -25240,6 +25661,9 @@ class PurpleSyncStatus(Enum):
 class IntegrationNotionListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -25279,7 +25703,8 @@ class IntegrationNotionListResponseItem:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, dataset_id: str, description: Optional[str], expires_in: Optional[float], id: str, last_synced_at: Optional[datetime], meta: Optional[Dict[str, Any]], name: Optional[str], sync_schedule: Optional[str], sync_status: Optional[PurpleSyncStatus], token: Optional[str], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, dataset_id: str, description: Optional[str], expires_in: Optional[float], id: str, last_synced_at: Optional[datetime], meta: Optional[Dict[str, Any]], name: Optional[str], sync_schedule: Optional[str], sync_status: Optional[PurpleSyncStatus], token: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.dataset_id = dataset_id
@@ -25297,6 +25722,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, dataset_id: s
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationNotionListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         dataset_id = from_str(obj.get("datasetId"))
@@ -25310,10 +25736,12 @@ def from_dict(obj: Any) -> 'IntegrationNotionListResponseItem':
         sync_status = from_union([PurpleSyncStatus, from_none], obj.get("syncStatus"))
         token = from_union([from_str, from_none], obj.get("token"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationNotionListResponseItem(blueprint_id, created_at, dataset_id, description, expires_in, id, last_synced_at, meta, name, sync_schedule, sync_status, token, updated_at)
+        return IntegrationNotionListResponseItem(alias, blueprint_id, created_at, dataset_id, description, expires_in, id, last_synced_at, meta, name, sync_schedule, sync_status, token, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -25374,6 +25802,9 @@ class FluffySyncStatus(Enum):
 class IntegrationNotionListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -25413,7 +25844,8 @@ class IntegrationNotionListStreamItemData:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, dataset_id: str, description: Optional[str], expires_in: Optional[float], id: str, last_synced_at: Optional[datetime], meta: Optional[Dict[str, Any]], name: Optional[str], sync_schedule: Optional[str], sync_status: Optional[FluffySyncStatus], token: Optional[str], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, dataset_id: str, description: Optional[str], expires_in: Optional[float], id: str, last_synced_at: Optional[datetime], meta: Optional[Dict[str, Any]], name: Optional[str], sync_schedule: Optional[str], sync_status: Optional[FluffySyncStatus], token: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.dataset_id = dataset_id
@@ -25431,6 +25863,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, dataset_id: s
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationNotionListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         dataset_id = from_str(obj.get("datasetId"))
@@ -25444,10 +25877,12 @@ def from_dict(obj: Any) -> 'IntegrationNotionListStreamItemData':
         sync_status = from_union([FluffySyncStatus, from_none], obj.get("syncStatus"))
         token = from_union([from_str, from_none], obj.get("token"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationNotionListStreamItemData(blueprint_id, created_at, dataset_id, description, expires_in, id, last_synced_at, meta, name, sync_schedule, sync_status, token, updated_at)
+        return IntegrationNotionListStreamItemData(alias, blueprint_id, created_at, dataset_id, description, expires_in, id, last_synced_at, meta, name, sync_schedule, sync_status, token, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -25572,6 +26007,9 @@ class IntegrationSitemapFetchResponseSyncStatus(Enum):
 class IntegrationSitemapFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -25620,7 +26058,8 @@ class IntegrationSitemapFetchResponse:
     url: Optional[str]
     """The URL to use for this Sitemap integration"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, dataset_id: str, description: Optional[str], expires_in: Optional[float], glob: Optional[str], id: str, javascript: Optional[bool], last_synced_at: Optional[datetime], meta: Optional[Dict[str, Any]], name: Optional[str], selectors: Optional[str], sync_schedule: Optional[str], sync_status: Optional[IntegrationSitemapFetchResponseSyncStatus], updated_at: float, url: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, dataset_id: str, description: Optional[str], expires_in: Optional[float], glob: Optional[str], id: str, javascript: Optional[bool], last_synced_at: Optional[datetime], meta: Optional[Dict[str, Any]], name: Optional[str], selectors: Optional[str], sync_schedule: Optional[str], sync_status: Optional[IntegrationSitemapFetchResponseSyncStatus], updated_at: float, url: Optional[str]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.dataset_id = dataset_id
@@ -25641,6 +26080,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, dataset_id: s
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationSitemapFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         dataset_id = from_str(obj.get("datasetId"))
@@ -25657,10 +26097,12 @@ def from_dict(obj: Any) -> 'IntegrationSitemapFetchResponse':
         sync_status = from_union([IntegrationSitemapFetchResponseSyncStatus, from_none], obj.get("syncStatus"))
         updated_at = from_float(obj.get("updatedAt"))
         url = from_union([from_str, from_none], obj.get("url"))
-        return IntegrationSitemapFetchResponse(blueprint_id, created_at, dataset_id, description, expires_in, glob, id, javascript, last_synced_at, meta, name, selectors, sync_schedule, sync_status, updated_at, url)
+        return IntegrationSitemapFetchResponse(alias, blueprint_id, created_at, dataset_id, description, expires_in, glob, id, javascript, last_synced_at, meta, name, selectors, sync_schedule, sync_status, updated_at, url)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -25752,116 +26194,8 @@ def to_dict(self) -> dict:
 class IntegrationSitemapUpdateRequest:
     """Blueprint properties"""
 
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
-
-    dataset_id: Optional[str]
-    """The ID of the dataset to use for this Sitemap integration"""
-
-    description: Optional[str]
-    """The associated description"""
-
-    expires_in: Optional[float]
-    """Record expiry in milliseconds"""
-
-    glob: Optional[str]
-    """The glob rules to use for this Sitemap integration"""
-
-    javascript: Optional[bool]
-    """Indicates if the Sitemap integration should use JavaScript during the spidering process"""
-
-    meta: Optional[Dict[str, Any]]
-    """Meta data information"""
-
-    name: Optional[str]
-    """The associated name"""
-
-    selectors: Optional[str]
-    """The selector rules to use for this Sitemap integration"""
-
-    sync_schedule: Optional[str]
-    """The sync schedule to use for this Sitemap integration"""
-
-    url: Optional[str]
-    """The URL to use for this Sitemap integration"""
-
-    def __init__(self, blueprint_id: Optional[str], dataset_id: Optional[str], description: Optional[str], expires_in: Optional[float], glob: Optional[str], javascript: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], selectors: Optional[str], sync_schedule: Optional[str], url: Optional[str]) -> None:
-        self.blueprint_id = blueprint_id
-        self.dataset_id = dataset_id
-        self.description = description
-        self.expires_in = expires_in
-        self.glob = glob
-        self.javascript = javascript
-        self.meta = meta
-        self.name = name
-        self.selectors = selectors
-        self.sync_schedule = sync_schedule
-        self.url = url
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSitemapUpdateRequest':
-        assert isinstance(obj, dict)
-        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        dataset_id = from_union([from_str, from_none], obj.get("datasetId"))
-        description = from_union([from_str, from_none], obj.get("description"))
-        expires_in = from_union([from_float, from_none], obj.get("expiresIn"))
-        glob = from_union([from_str, from_none], obj.get("glob"))
-        javascript = from_union([from_bool, from_none], obj.get("javascript"))
-        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        name = from_union([from_str, from_none], obj.get("name"))
-        selectors = from_union([from_str, from_none], obj.get("selectors"))
-        sync_schedule = from_union([from_str, from_none], obj.get("syncSchedule"))
-        url = from_union([from_str, from_none], obj.get("url"))
-        return IntegrationSitemapUpdateRequest(blueprint_id, dataset_id, description, expires_in, glob, javascript, meta, name, selectors, sync_schedule, url)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.dataset_id is not None:
-            result["datasetId"] = from_union([from_str, from_none], self.dataset_id)
-        if self.description is not None:
-            result["description"] = from_union([from_str, from_none], self.description)
-        if self.expires_in is not None:
-            result["expiresIn"] = from_union([to_float, from_none], self.expires_in)
-        if self.glob is not None:
-            result["glob"] = from_union([from_str, from_none], self.glob)
-        if self.javascript is not None:
-            result["javascript"] = from_union([from_bool, from_none], self.javascript)
-        if self.meta is not None:
-            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        if self.name is not None:
-            result["name"] = from_union([from_str, from_none], self.name)
-        if self.selectors is not None:
-            result["selectors"] = from_union([from_str, from_none], self.selectors)
-        if self.sync_schedule is not None:
-            result["syncSchedule"] = from_union([from_str, from_none], self.sync_schedule)
-        if self.url is not None:
-            result["url"] = from_union([from_str, from_none], self.url)
-        return result
-
-
-class IntegrationSitemapUpdateResponse:
-    id: str
-    """The ID of the Sitemap Integration"""
-
-    def __init__(self, id: str) -> None:
-        self.id = id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSitemapUpdateResponse':
-        assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
-        return IntegrationSitemapUpdateResponse(id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["id"] = from_str(self.id)
-        return result
-
-
-class IntegrationSitemapCreateRequest:
-    """Blueprint properties"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -25896,7 +26230,126 @@ class IntegrationSitemapCreateRequest:
     url: Optional[str]
     """The URL to use for this Sitemap integration"""
 
-    def __init__(self, blueprint_id: Optional[str], dataset_id: Optional[str], description: Optional[str], expires_in: Optional[float], glob: Optional[str], javascript: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], selectors: Optional[str], sync_schedule: Optional[str], url: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], dataset_id: Optional[str], description: Optional[str], expires_in: Optional[float], glob: Optional[str], javascript: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], selectors: Optional[str], sync_schedule: Optional[str], url: Optional[str]) -> None:
+        self.alias = alias
+        self.blueprint_id = blueprint_id
+        self.dataset_id = dataset_id
+        self.description = description
+        self.expires_in = expires_in
+        self.glob = glob
+        self.javascript = javascript
+        self.meta = meta
+        self.name = name
+        self.selectors = selectors
+        self.sync_schedule = sync_schedule
+        self.url = url
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationSitemapUpdateRequest':
+        assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        dataset_id = from_union([from_str, from_none], obj.get("datasetId"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        expires_in = from_union([from_float, from_none], obj.get("expiresIn"))
+        glob = from_union([from_str, from_none], obj.get("glob"))
+        javascript = from_union([from_bool, from_none], obj.get("javascript"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        selectors = from_union([from_str, from_none], obj.get("selectors"))
+        sync_schedule = from_union([from_str, from_none], obj.get("syncSchedule"))
+        url = from_union([from_str, from_none], obj.get("url"))
+        return IntegrationSitemapUpdateRequest(alias, blueprint_id, dataset_id, description, expires_in, glob, javascript, meta, name, selectors, sync_schedule, url)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.dataset_id is not None:
+            result["datasetId"] = from_union([from_str, from_none], self.dataset_id)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        if self.expires_in is not None:
+            result["expiresIn"] = from_union([to_float, from_none], self.expires_in)
+        if self.glob is not None:
+            result["glob"] = from_union([from_str, from_none], self.glob)
+        if self.javascript is not None:
+            result["javascript"] = from_union([from_bool, from_none], self.javascript)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.selectors is not None:
+            result["selectors"] = from_union([from_str, from_none], self.selectors)
+        if self.sync_schedule is not None:
+            result["syncSchedule"] = from_union([from_str, from_none], self.sync_schedule)
+        if self.url is not None:
+            result["url"] = from_union([from_str, from_none], self.url)
+        return result
+
+
+class IntegrationSitemapUpdateResponse:
+    id: str
+    """The ID of the Sitemap Integration"""
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationSitemapUpdateResponse':
+        assert isinstance(obj, dict)
+        id = from_str(obj.get("id"))
+        return IntegrationSitemapUpdateResponse(id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["id"] = from_str(self.id)
+        return result
+
+
+class IntegrationSitemapCreateRequest:
+    """Blueprint properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    dataset_id: Optional[str]
+    """The ID of the dataset to use for this Sitemap integration"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    expires_in: Optional[float]
+    """Record expiry in milliseconds"""
+
+    glob: Optional[str]
+    """The glob rules to use for this Sitemap integration"""
+
+    javascript: Optional[bool]
+    """Indicates if the Sitemap integration should use JavaScript during the spidering process"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    selectors: Optional[str]
+    """The selector rules to use for this Sitemap integration"""
+
+    sync_schedule: Optional[str]
+    """The sync schedule to use for this Sitemap integration"""
+
+    url: Optional[str]
+    """The URL to use for this Sitemap integration"""
+
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], dataset_id: Optional[str], description: Optional[str], expires_in: Optional[float], glob: Optional[str], javascript: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], selectors: Optional[str], sync_schedule: Optional[str], url: Optional[str]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.dataset_id = dataset_id
         self.description = description
@@ -25912,6 +26365,7 @@ def __init__(self, blueprint_id: Optional[str], dataset_id: Optional[str], descr
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationSitemapCreateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         dataset_id = from_union([from_str, from_none], obj.get("datasetId"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -25923,10 +26377,12 @@ def from_dict(obj: Any) -> 'IntegrationSitemapCreateRequest':
         selectors = from_union([from_str, from_none], obj.get("selectors"))
         sync_schedule = from_union([from_str, from_none], obj.get("syncSchedule"))
         url = from_union([from_str, from_none], obj.get("url"))
-        return IntegrationSitemapCreateRequest(blueprint_id, dataset_id, description, expires_in, glob, javascript, meta, name, selectors, sync_schedule, url)
+        return IntegrationSitemapCreateRequest(alias, blueprint_id, dataset_id, description, expires_in, glob, javascript, meta, name, selectors, sync_schedule, url)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.dataset_id is not None:
@@ -26030,6 +26486,9 @@ class TentacledSyncStatus(Enum):
 class IntegrationSitemapListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -26078,7 +26537,8 @@ class IntegrationSitemapListResponseItem:
     url: Optional[str]
     """The URL to use for this Sitemap integration"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, dataset_id: str, description: Optional[str], expires_in: Optional[float], glob: Optional[str], id: str, javascript: Optional[bool], last_synced_at: Optional[datetime], meta: Optional[Dict[str, Any]], name: Optional[str], selectors: Optional[str], sync_schedule: Optional[str], sync_status: Optional[TentacledSyncStatus], updated_at: float, url: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, dataset_id: str, description: Optional[str], expires_in: Optional[float], glob: Optional[str], id: str, javascript: Optional[bool], last_synced_at: Optional[datetime], meta: Optional[Dict[str, Any]], name: Optional[str], selectors: Optional[str], sync_schedule: Optional[str], sync_status: Optional[TentacledSyncStatus], updated_at: float, url: Optional[str]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.dataset_id = dataset_id
@@ -26099,6 +26559,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, dataset_id: s
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationSitemapListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         dataset_id = from_str(obj.get("datasetId"))
@@ -26115,10 +26576,12 @@ def from_dict(obj: Any) -> 'IntegrationSitemapListResponseItem':
         sync_status = from_union([TentacledSyncStatus, from_none], obj.get("syncStatus"))
         updated_at = from_float(obj.get("updatedAt"))
         url = from_union([from_str, from_none], obj.get("url"))
-        return IntegrationSitemapListResponseItem(blueprint_id, created_at, dataset_id, description, expires_in, glob, id, javascript, last_synced_at, meta, name, selectors, sync_schedule, sync_status, updated_at, url)
+        return IntegrationSitemapListResponseItem(alias, blueprint_id, created_at, dataset_id, description, expires_in, glob, id, javascript, last_synced_at, meta, name, selectors, sync_schedule, sync_status, updated_at, url)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -26185,6 +26648,9 @@ class StickySyncStatus(Enum):
 class IntegrationSitemapListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -26233,7 +26699,8 @@ class IntegrationSitemapListStreamItemData:
     url: Optional[str]
     """The URL to use for this Sitemap integration"""
 
-    def __init__(self, blueprint_id: Optional[str], created_at: float, dataset_id: str, description: Optional[str], expires_in: Optional[float], glob: Optional[str], id: str, javascript: Optional[bool], last_synced_at: Optional[datetime], meta: Optional[Dict[str, Any]], name: Optional[str], selectors: Optional[str], sync_schedule: Optional[str], sync_status: Optional[StickySyncStatus], updated_at: float, url: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, dataset_id: str, description: Optional[str], expires_in: Optional[float], glob: Optional[str], id: str, javascript: Optional[bool], last_synced_at: Optional[datetime], meta: Optional[Dict[str, Any]], name: Optional[str], selectors: Optional[str], sync_schedule: Optional[str], sync_status: Optional[StickySyncStatus], updated_at: float, url: Optional[str]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.created_at = created_at
         self.dataset_id = dataset_id
@@ -26254,6 +26721,7 @@ def __init__(self, blueprint_id: Optional[str], created_at: float, dataset_id: s
     @staticmethod
     def from_dict(obj: Any) -> 'IntegrationSitemapListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         created_at = from_float(obj.get("createdAt"))
         dataset_id = from_str(obj.get("datasetId"))
@@ -26270,10 +26738,12 @@ def from_dict(obj: Any) -> 'IntegrationSitemapListStreamItemData':
         sync_status = from_union([StickySyncStatus, from_none], obj.get("syncStatus"))
         updated_at = from_float(obj.get("updatedAt"))
         url = from_union([from_str, from_none], obj.get("url"))
-        return IntegrationSitemapListStreamItemData(blueprint_id, created_at, dataset_id, description, expires_in, glob, id, javascript, last_synced_at, meta, name, selectors, sync_schedule, sync_status, updated_at, url)
+        return IntegrationSitemapListStreamItemData(alias, blueprint_id, created_at, dataset_id, description, expires_in, glob, id, javascript, last_synced_at, meta, name, selectors, sync_schedule, sync_status, updated_at, url)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         result["createdAt"] = to_float(self.created_at)
@@ -26336,37 +26806,37 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationSlackDeleteParams:
-    slack_integration_id: str
-    """The ID of the Slack integration"""
+class SkillServerIntegrationDeleteParams:
+    skillserver_integration_id: str
+    """The ID of the SkillServer integration"""
 
-    def __init__(self, slack_integration_id: str) -> None:
-        self.slack_integration_id = slack_integration_id
+    def __init__(self, skillserver_integration_id: str) -> None:
+        self.skillserver_integration_id = skillserver_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackDeleteParams':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationDeleteParams':
         assert isinstance(obj, dict)
-        slack_integration_id = from_str(obj.get("slackIntegrationId"))
-        return IntegrationSlackDeleteParams(slack_integration_id)
+        skillserver_integration_id = from_str(obj.get("skillserverIntegrationId"))
+        return SkillServerIntegrationDeleteParams(skillserver_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["slackIntegrationId"] = from_str(self.slack_integration_id)
+        result["skillserverIntegrationId"] = from_str(self.skillserver_integration_id)
         return result
 
 
-class IntegrationSlackDeleteResponse:
+class SkillServerIntegrationDeleteResponse:
     id: str
-    """The ID of the deleted Slack integration"""
+    """The ID of the deleted SkillServer integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackDeleteResponse':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationDeleteResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationSlackDeleteResponse(id)
+        return SkillServerIntegrationDeleteResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -26374,49 +26844,34 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationSlackFetchParams:
-    slack_integration_id: str
-    """The ID of the Slack integration to retrieve"""
+class SkillServerIntegrationFetchParams:
+    skillserver_integration_id: str
+    """The ID of the SkillServer integration to retrieve"""
 
-    def __init__(self, slack_integration_id: str) -> None:
-        self.slack_integration_id = slack_integration_id
+    def __init__(self, skillserver_integration_id: str) -> None:
+        self.skillserver_integration_id = skillserver_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackFetchParams':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationFetchParams':
         assert isinstance(obj, dict)
-        slack_integration_id = from_str(obj.get("slackIntegrationId"))
-        return IntegrationSlackFetchParams(slack_integration_id)
+        skillserver_integration_id = from_str(obj.get("skillserverIntegrationId"))
+        return SkillServerIntegrationFetchParams(skillserver_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["slackIntegrationId"] = from_str(self.slack_integration_id)
+        result["skillserverIntegrationId"] = from_str(self.skillserver_integration_id)
         return result
 
 
-class IntegrationSlackFetchResponse:
+class SkillServerIntegrationFetchResponse:
     """Blueprint properties"""
 
-    allow_from: Optional[str]
-    """Restrict which Slack users or channels can interact with this integration. Accepts Slack
-    user IDs (U…/W…), channel IDs (C…/G…/D…), @username, or
-    """
-    auto_respond: Optional[str]
-    """Configure automatic response behavior. Use '@all' to respond to all messages, '@agent
-    <instructions>' for agent-powered decisions, or custom instructions for lightweight LLM
-    filtering. Null/empty defaults to current behavior (DMs, mentions, threads only).
-    """
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: Optional[str]
-    """The ID of the bot this configuration is using"""
-
-    bot_token: Optional[str]
-    """The bot token (returned as '********' if configured, null otherwise)"""
-
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
@@ -26432,84 +26887,43 @@ class IntegrationSlackFetchResponse:
     name: Optional[str]
     """The associated name"""
 
-    ratings: Optional[bool]
-    """Whether to enable ratings buttons feature"""
-
-    references: Optional[bool]
-    """Whether to enable references feature"""
-
-    session_duration: Optional[float]
-    """The session duration for the Slack integration"""
-
-    signing_secret: Optional[str]
-    """The signing secret (returned as '********' if configured, null otherwise)"""
+    skillset_id: Optional[str]
+    """The ID of the skillset"""
 
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    user_token: Optional[str]
-    """The user token (returned as '********' if configured, null otherwise)"""
-
-    visible_messages: Optional[float]
-    """The number of visible messages outside of the new thread"""
-
-    def __init__(self, allow_from: Optional[str], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], ratings: Optional[bool], references: Optional[bool], session_duration: Optional[float], signing_secret: Optional[str], updated_at: float, user_token: Optional[str], visible_messages: Optional[float]) -> None:
-        self.allow_from = allow_from
-        self.auto_respond = auto_respond
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], skillset_id: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
-        self.bot_id = bot_id
-        self.bot_token = bot_token
-        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
         self.id = id
         self.meta = meta
         self.name = name
-        self.ratings = ratings
-        self.references = references
-        self.session_duration = session_duration
-        self.signing_secret = signing_secret
+        self.skillset_id = skillset_id
         self.updated_at = updated_at
-        self.user_token = user_token
-        self.visible_messages = visible_messages
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackFetchResponse':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationFetchResponse':
         assert isinstance(obj, dict)
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
-        bot_token = from_union([from_str, from_none], obj.get("botToken"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        ratings = from_union([from_bool, from_none], obj.get("ratings"))
-        references = from_union([from_bool, from_none], obj.get("references"))
-        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        signing_secret = from_union([from_str, from_none], obj.get("signingSecret"))
+        skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
         updated_at = from_float(obj.get("updatedAt"))
-        user_token = from_union([from_str, from_none], obj.get("userToken"))
-        visible_messages = from_union([from_float, from_none], obj.get("visibleMessages"))
-        return IntegrationSlackFetchResponse(allow_from, auto_respond, blueprint_id, bot_id, bot_token, contact_collection, created_at, description, id, meta, name, ratings, references, session_duration, signing_secret, updated_at, user_token, visible_messages)
+        return SkillServerIntegrationFetchResponse(alias, blueprint_id, created_at, description, id, meta, name, skillset_id, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.auto_respond is not None:
-            result["autoRespond"] = from_union([from_str, from_none], self.auto_respond)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.bot_token is not None:
-            result["botToken"] = from_union([from_str, from_none], self.bot_token)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
@@ -26518,102 +26932,147 @@ def to_dict(self) -> dict:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.ratings is not None:
-            result["ratings"] = from_union([from_bool, from_none], self.ratings)
-        if self.references is not None:
-            result["references"] = from_union([from_bool, from_none], self.references)
-        if self.session_duration is not None:
-            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.signing_secret is not None:
-            result["signingSecret"] = from_union([from_str, from_none], self.signing_secret)
+        if self.skillset_id is not None:
+            result["skillsetId"] = from_union([from_str, from_none], self.skillset_id)
         result["updatedAt"] = to_float(self.updated_at)
-        if self.user_token is not None:
-            result["userToken"] = from_union([from_str, from_none], self.user_token)
-        if self.visible_messages is not None:
-            result["visibleMessages"] = from_union([to_float, from_none], self.visible_messages)
         return result
 
 
-class IntegrationSlackSetupParams:
-    slack_integration_id: str
-    """The ID of the Slack integration"""
+class SkillServerManualFetchParams:
+    skillserver_integration_id: str
+    """The ID of the SkillServer integration"""
 
-    def __init__(self, slack_integration_id: str) -> None:
-        self.slack_integration_id = slack_integration_id
+    def __init__(self, skillserver_integration_id: str) -> None:
+        self.skillserver_integration_id = skillserver_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackSetupParams':
+    def from_dict(obj: Any) -> 'SkillServerManualFetchParams':
         assert isinstance(obj, dict)
-        slack_integration_id = from_str(obj.get("slackIntegrationId"))
-        return IntegrationSlackSetupParams(slack_integration_id)
+        skillserver_integration_id = from_str(obj.get("skillserverIntegrationId"))
+        return SkillServerManualFetchParams(skillserver_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["slackIntegrationId"] = from_str(self.slack_integration_id)
+        result["skillserverIntegrationId"] = from_str(self.skillserver_integration_id)
         return result
 
 
-class IntegrationSlackSetupResponse:
-    id: str
-    """The ID of the setup Slack integration"""
+class Format(Enum):
+    """Set to "json" to receive a JSON response"""
 
-    def __init__(self, id: str) -> None:
-        self.id = id
+    JSON = "json"
+
+
+class SkillServerAbilityInvokeParams:
+    format: Optional[Format]
+    """Set to "json" to receive a JSON response"""
+
+    session: Optional[str]
+    """Optional session id to group tool state across calls"""
+
+    skillserver_integration_id: str
+    """The ID of the SkillServer integration"""
+
+    def __init__(self, format: Optional[Format], session: Optional[str], skillserver_integration_id: str) -> None:
+        self.format = format
+        self.session = session
+        self.skillserver_integration_id = skillserver_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackSetupResponse':
+    def from_dict(obj: Any) -> 'SkillServerAbilityInvokeParams':
         assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
-        return IntegrationSlackSetupResponse(id)
+        format = from_union([Format, from_none], obj.get("format"))
+        session = from_union([from_str, from_none], obj.get("session"))
+        skillserver_integration_id = from_str(obj.get("skillserverIntegrationId"))
+        return SkillServerAbilityInvokeParams(format, session, skillserver_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["id"] = from_str(self.id)
+        if self.format is not None:
+            result["format"] = from_union([lambda x: to_enum(Format, x), from_none], self.format)
+        if self.session is not None:
+            result["session"] = from_union([from_str, from_none], self.session)
+        result["skillserverIntegrationId"] = from_str(self.skillserver_integration_id)
         return result
 
 
-class IntegrationSlackUpdateParams:
-    slack_integration_id: str
-    """The ID of the Slack integration"""
+class SkillServerAbilityInvokeRequest:
+    ability: str
+    """The name of the ability to invoke (as listed in the manual)"""
 
-    def __init__(self, slack_integration_id: str) -> None:
-        self.slack_integration_id = slack_integration_id
+    input: Optional[Dict[str, Any]]
+    """The ability input"""
+
+    def __init__(self, ability: str, input: Optional[Dict[str, Any]]) -> None:
+        self.ability = ability
+        self.input = input
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackUpdateParams':
+    def from_dict(obj: Any) -> 'SkillServerAbilityInvokeRequest':
         assert isinstance(obj, dict)
-        slack_integration_id = from_str(obj.get("slackIntegrationId"))
-        return IntegrationSlackUpdateParams(slack_integration_id)
+        ability = from_str(obj.get("ability"))
+        input = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("input"))
+        return SkillServerAbilityInvokeRequest(ability, input)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["slackIntegrationId"] = from_str(self.slack_integration_id)
+        result["ability"] = from_str(self.ability)
+        if self.input is not None:
+            result["input"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.input)
         return result
 
 
-class IntegrationSlackUpdateRequest:
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class SkillServerAbilityInvokeResponse:
+    error: Optional[str]
+    result: Any
 
-    allow_from: Optional[str]
-    """Restrict which Slack users or channels can interact with this integration. Accepts Slack
-    user IDs (U…/W…), channel IDs (C…/G…/D…), @username, or
-    """
-    auto_respond: Optional[str]
-    """Configure automatic response behavior. Use '@all' to respond to all messages, '@agent
-    <instructions>' for agent-powered decisions, or custom instructions for lightweight LLM
-    filtering. Null/empty defaults to current behavior (DMs, mentions, threads only).
-    """
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
+    def __init__(self, error: Optional[str], result: Any) -> None:
+        self.error = error
+        self.result = result
 
-    bot_id: Optional[str]
-    """The ID of the bot this configuration is using"""
+    @staticmethod
+    def from_dict(obj: Any) -> 'SkillServerAbilityInvokeResponse':
+        assert isinstance(obj, dict)
+        error = from_union([from_str, from_none], obj.get("error"))
+        result = obj.get("result")
+        return SkillServerAbilityInvokeResponse(error, result)
 
-    bot_token: Optional[str]
-    """The bot token for the Slack integration"""
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.error is not None:
+            result["error"] = from_union([from_str, from_none], self.error)
+        if self.result is not None:
+            result["result"] = self.result
+        return result
 
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
+
+class SkillServerIntegrationUpdateParams:
+    skillserver_integration_id: str
+    """The ID of the SkillServer integration"""
+
+    def __init__(self, skillserver_integration_id: str) -> None:
+        self.skillserver_integration_id = skillserver_integration_id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SkillServerIntegrationUpdateParams':
+        assert isinstance(obj, dict)
+        skillserver_integration_id = from_str(obj.get("skillserverIntegrationId"))
+        return SkillServerIntegrationUpdateParams(skillserver_integration_id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["skillserverIntegrationId"] = from_str(self.skillserver_integration_id)
+        return result
+
+
+class SkillServerIntegrationUpdateRequest:
+    """Blueprint properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
 
     description: Optional[str]
     """The associated description"""
@@ -26624,108 +27083,57 @@ class IntegrationSlackUpdateRequest:
     name: Optional[str]
     """The associated name"""
 
-    ratings: Optional[bool]
-    """Whether to enable ratings buttons feature"""
-
-    references: Optional[bool]
-    """Whether to enable references feature"""
-
-    session_duration: Optional[float]
-    """The session duration for the Slack integration"""
-
-    signing_secret: Optional[str]
-    """The signing secret for the Slack integration"""
-
-    user_token: Optional[str]
-    """The user token for the Slack integration"""
-
-    visible_messages: Optional[float]
-    """The number of visible messages outside of the new thread"""
+    skillset_id: Optional[str]
+    """The ID of the skillset"""
 
-    def __init__(self, allow_from: Optional[str], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], ratings: Optional[bool], references: Optional[bool], session_duration: Optional[float], signing_secret: Optional[str], user_token: Optional[str], visible_messages: Optional[float]) -> None:
-        self.allow_from = allow_from
-        self.auto_respond = auto_respond
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], skillset_id: Optional[str]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
-        self.bot_id = bot_id
-        self.bot_token = bot_token
-        self.contact_collection = contact_collection
         self.description = description
         self.meta = meta
         self.name = name
-        self.ratings = ratings
-        self.references = references
-        self.session_duration = session_duration
-        self.signing_secret = signing_secret
-        self.user_token = user_token
-        self.visible_messages = visible_messages
+        self.skillset_id = skillset_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackUpdateRequest':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationUpdateRequest':
         assert isinstance(obj, dict)
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
-        bot_token = from_union([from_str, from_none], obj.get("botToken"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        ratings = from_union([from_bool, from_none], obj.get("ratings"))
-        references = from_union([from_bool, from_none], obj.get("references"))
-        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        signing_secret = from_union([from_str, from_none], obj.get("signingSecret"))
-        user_token = from_union([from_str, from_none], obj.get("userToken"))
-        visible_messages = from_union([from_float, from_none], obj.get("visibleMessages"))
-        return IntegrationSlackUpdateRequest(allow_from, auto_respond, blueprint_id, bot_id, bot_token, contact_collection, description, meta, name, ratings, references, session_duration, signing_secret, user_token, visible_messages)
+        skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
+        return SkillServerIntegrationUpdateRequest(alias, blueprint_id, description, meta, name, skillset_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.auto_respond is not None:
-            result["autoRespond"] = from_union([from_str, from_none], self.auto_respond)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.bot_token is not None:
-            result["botToken"] = from_union([from_str, from_none], self.bot_token)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.ratings is not None:
-            result["ratings"] = from_union([from_bool, from_none], self.ratings)
-        if self.references is not None:
-            result["references"] = from_union([from_bool, from_none], self.references)
-        if self.session_duration is not None:
-            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.signing_secret is not None:
-            result["signingSecret"] = from_union([from_str, from_none], self.signing_secret)
-        if self.user_token is not None:
-            result["userToken"] = from_union([from_str, from_none], self.user_token)
-        if self.visible_messages is not None:
-            result["visibleMessages"] = from_union([to_float, from_none], self.visible_messages)
+        if self.skillset_id is not None:
+            result["skillsetId"] = from_union([from_str, from_none], self.skillset_id)
         return result
 
 
-class IntegrationSlackUpdateResponse:
+class SkillServerIntegrationUpdateResponse:
     id: str
-    """The ID of the Slack Integration"""
+    """The ID of the SkillServer Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackUpdateResponse':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationUpdateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationSlackUpdateResponse(id)
+        return SkillServerIntegrationUpdateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -26733,30 +27141,15 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationSlackCreateRequest:
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class SkillServerIntegrationCreateRequest:
+    """Blueprint properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
-    allow_from: Optional[str]
-    """Restrict which Slack users or channels can interact with this integration. Accepts Slack
-    user IDs (U…/W…), channel IDs (C…/G…/D…), @username, or
-    """
-    auto_respond: Optional[str]
-    """Configure automatic response behavior. Use '@all' to respond to all messages, '@agent
-    <instructions>' for agent-powered decisions, or custom instructions for lightweight LLM
-    filtering. Null/empty defaults to current behavior (DMs, mentions, threads only).
-    """
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: Optional[str]
-    """The ID of the bot this configuration is using"""
-
-    bot_token: Optional[str]
-    """The bot token for the Slack integration"""
-
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     description: Optional[str]
     """The associated description"""
 
@@ -26766,108 +27159,57 @@ class IntegrationSlackCreateRequest:
     name: Optional[str]
     """The associated name"""
 
-    ratings: Optional[bool]
-    """Whether to enable ratings buttons feature"""
-
-    references: Optional[bool]
-    """Whether to enable references feature"""
-
-    session_duration: Optional[float]
-    """The session duration for the Slack integration"""
-
-    signing_secret: Optional[str]
-    """The signing secret for the Slack integration"""
-
-    user_token: Optional[str]
-    """The user token for the Slack integration"""
-
-    visible_messages: Optional[float]
-    """The number of visible messages outside of the new thread"""
+    skillset_id: Optional[str]
+    """The ID of the skillset"""
 
-    def __init__(self, allow_from: Optional[str], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], ratings: Optional[bool], references: Optional[bool], session_duration: Optional[float], signing_secret: Optional[str], user_token: Optional[str], visible_messages: Optional[float]) -> None:
-        self.allow_from = allow_from
-        self.auto_respond = auto_respond
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], skillset_id: Optional[str]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
-        self.bot_id = bot_id
-        self.bot_token = bot_token
-        self.contact_collection = contact_collection
         self.description = description
         self.meta = meta
         self.name = name
-        self.ratings = ratings
-        self.references = references
-        self.session_duration = session_duration
-        self.signing_secret = signing_secret
-        self.user_token = user_token
-        self.visible_messages = visible_messages
+        self.skillset_id = skillset_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackCreateRequest':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationCreateRequest':
         assert isinstance(obj, dict)
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
-        bot_token = from_union([from_str, from_none], obj.get("botToken"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        ratings = from_union([from_bool, from_none], obj.get("ratings"))
-        references = from_union([from_bool, from_none], obj.get("references"))
-        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        signing_secret = from_union([from_str, from_none], obj.get("signingSecret"))
-        user_token = from_union([from_str, from_none], obj.get("userToken"))
-        visible_messages = from_union([from_float, from_none], obj.get("visibleMessages"))
-        return IntegrationSlackCreateRequest(allow_from, auto_respond, blueprint_id, bot_id, bot_token, contact_collection, description, meta, name, ratings, references, session_duration, signing_secret, user_token, visible_messages)
+        skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
+        return SkillServerIntegrationCreateRequest(alias, blueprint_id, description, meta, name, skillset_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.auto_respond is not None:
-            result["autoRespond"] = from_union([from_str, from_none], self.auto_respond)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.bot_token is not None:
-            result["botToken"] = from_union([from_str, from_none], self.bot_token)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.ratings is not None:
-            result["ratings"] = from_union([from_bool, from_none], self.ratings)
-        if self.references is not None:
-            result["references"] = from_union([from_bool, from_none], self.references)
-        if self.session_duration is not None:
-            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.signing_secret is not None:
-            result["signingSecret"] = from_union([from_str, from_none], self.signing_secret)
-        if self.user_token is not None:
-            result["userToken"] = from_union([from_str, from_none], self.user_token)
-        if self.visible_messages is not None:
-            result["visibleMessages"] = from_union([to_float, from_none], self.visible_messages)
+        if self.skillset_id is not None:
+            result["skillsetId"] = from_union([from_str, from_none], self.skillset_id)
         return result
 
 
-class IntegrationSlackCreateResponse:
+class SkillServerIntegrationCreateResponse:
     id: str
-    """The ID of the Slack Integration"""
+    """The ID of the SkillServer Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackCreateResponse':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationCreateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationSlackCreateResponse(id)
+        return SkillServerIntegrationCreateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -26875,40 +27217,40 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationSlackListParamsOrder(Enum):
+class SkillServerIntegrationListParamsOrder(Enum):
     """The order of the paginated items"""
 
     ASC = "asc"
     DESC = "desc"
 
 
-class IntegrationSlackListParams:
+class SkillServerIntegrationListParams:
     cursor: Optional[str]
     """The cursor to use for pagination"""
 
     meta: Optional[Dict[str, str]]
-    """Key-value pairs to filter the partner users by metadata"""
+    """Key-value pairs to filter by metadata"""
 
-    order: Optional[IntegrationSlackListParamsOrder]
+    order: Optional[SkillServerIntegrationListParamsOrder]
     """The order of the paginated items"""
 
     take: Optional[int]
     """The number of items to retrieve"""
 
-    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[IntegrationSlackListParamsOrder], take: Optional[int]) -> None:
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[SkillServerIntegrationListParamsOrder], take: Optional[int]) -> None:
         self.cursor = cursor
         self.meta = meta
         self.order = order
         self.take = take
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackListParams':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationListParams':
         assert isinstance(obj, dict)
         cursor = from_union([from_str, from_none], obj.get("cursor"))
         meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
-        order = from_union([IntegrationSlackListParamsOrder, from_none], obj.get("order"))
+        order = from_union([SkillServerIntegrationListParamsOrder, from_none], obj.get("order"))
         take = from_union([from_int, from_none], obj.get("take"))
-        return IntegrationSlackListParams(cursor, meta, order, take)
+        return SkillServerIntegrationListParams(cursor, meta, order, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -26917,36 +27259,21 @@ def to_dict(self) -> dict:
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
         if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(IntegrationSlackListParamsOrder, x), from_none], self.order)
+            result["order"] = from_union([lambda x: to_enum(SkillServerIntegrationListParamsOrder, x), from_none], self.order)
         if self.take is not None:
             result["take"] = from_union([from_int, from_none], self.take)
         return result
 
 
-class IntegrationSlackListResponseItem:
+class SkillServerIntegrationListResponseItem:
     """Blueprint properties"""
 
-    allow_from: Optional[str]
-    """Restrict which Slack users or channels can interact with this integration. Accepts Slack
-    user IDs (U…/W…), channel IDs (C…/G…/D…), @username, or
-    """
-    auto_respond: Optional[str]
-    """Configure automatic response behavior. Use '@all' to respond to all messages, '@agent
-    <instructions>' for agent-powered decisions, or custom instructions for lightweight LLM
-    filtering. Null/empty defaults to current behavior (DMs, mentions, threads only).
-    """
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: Optional[str]
-    """The ID of the bot this configuration is using"""
-
-    bot_token: Optional[str]
-    """The bot token (returned as '********' if configured, null otherwise)"""
-
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
@@ -26962,84 +27289,43 @@ class IntegrationSlackListResponseItem:
     name: Optional[str]
     """The associated name"""
 
-    ratings: Optional[bool]
-    """Whether to enable ratings buttons feature"""
-
-    references: Optional[bool]
-    """Whether to enable references feature"""
-
-    session_duration: Optional[float]
-    """The session duration for the Slack integration"""
-
-    signing_secret: Optional[str]
-    """The signing secret (returned as '********' if configured, null otherwise)"""
+    skillset_id: Optional[str]
+    """The ID of the skillset"""
 
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    user_token: Optional[str]
-    """The user token (returned as '********' if configured, null otherwise)"""
-
-    visible_messages: Optional[float]
-    """The number of visible messages outside of the new thread"""
-
-    def __init__(self, allow_from: Optional[str], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], ratings: Optional[bool], references: Optional[bool], session_duration: Optional[float], signing_secret: Optional[str], updated_at: float, user_token: Optional[str], visible_messages: Optional[float]) -> None:
-        self.allow_from = allow_from
-        self.auto_respond = auto_respond
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], skillset_id: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
-        self.bot_id = bot_id
-        self.bot_token = bot_token
-        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
         self.id = id
         self.meta = meta
         self.name = name
-        self.ratings = ratings
-        self.references = references
-        self.session_duration = session_duration
-        self.signing_secret = signing_secret
+        self.skillset_id = skillset_id
         self.updated_at = updated_at
-        self.user_token = user_token
-        self.visible_messages = visible_messages
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackListResponseItem':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationListResponseItem':
         assert isinstance(obj, dict)
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
-        bot_token = from_union([from_str, from_none], obj.get("botToken"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        ratings = from_union([from_bool, from_none], obj.get("ratings"))
-        references = from_union([from_bool, from_none], obj.get("references"))
-        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        signing_secret = from_union([from_str, from_none], obj.get("signingSecret"))
+        skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
         updated_at = from_float(obj.get("updatedAt"))
-        user_token = from_union([from_str, from_none], obj.get("userToken"))
-        visible_messages = from_union([from_float, from_none], obj.get("visibleMessages"))
-        return IntegrationSlackListResponseItem(allow_from, auto_respond, blueprint_id, bot_id, bot_token, contact_collection, created_at, description, id, meta, name, ratings, references, session_duration, signing_secret, updated_at, user_token, visible_messages)
+        return SkillServerIntegrationListResponseItem(alias, blueprint_id, created_at, description, id, meta, name, skillset_id, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.auto_respond is not None:
-            result["autoRespond"] = from_union([from_str, from_none], self.auto_respond)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.bot_token is not None:
-            result["botToken"] = from_union([from_str, from_none], self.bot_token)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
@@ -27048,70 +27334,45 @@ def to_dict(self) -> dict:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.ratings is not None:
-            result["ratings"] = from_union([from_bool, from_none], self.ratings)
-        if self.references is not None:
-            result["references"] = from_union([from_bool, from_none], self.references)
-        if self.session_duration is not None:
-            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.signing_secret is not None:
-            result["signingSecret"] = from_union([from_str, from_none], self.signing_secret)
+        if self.skillset_id is not None:
+            result["skillsetId"] = from_union([from_str, from_none], self.skillset_id)
         result["updatedAt"] = to_float(self.updated_at)
-        if self.user_token is not None:
-            result["userToken"] = from_union([from_str, from_none], self.user_token)
-        if self.visible_messages is not None:
-            result["visibleMessages"] = from_union([to_float, from_none], self.visible_messages)
         return result
 
 
-class IntegrationSlackListResponse:
+class SkillServerIntegrationListResponse:
     cursor: str
     """Cursor for fetching the next page"""
 
-    items: List[IntegrationSlackListResponseItem]
+    items: List[SkillServerIntegrationListResponseItem]
 
-    def __init__(self, cursor: str, items: List[IntegrationSlackListResponseItem]) -> None:
+    def __init__(self, cursor: str, items: List[SkillServerIntegrationListResponseItem]) -> None:
         self.cursor = cursor
         self.items = items
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackListResponse':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationListResponse':
         assert isinstance(obj, dict)
         cursor = from_str(obj.get("cursor"))
-        items = from_list(IntegrationSlackListResponseItem.from_dict, obj.get("items"))
-        return IntegrationSlackListResponse(cursor, items)
+        items = from_list(SkillServerIntegrationListResponseItem.from_dict, obj.get("items"))
+        return SkillServerIntegrationListResponse(cursor, items)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["cursor"] = from_str(self.cursor)
-        result["items"] = from_list(lambda x: to_class(IntegrationSlackListResponseItem, x), self.items)
+        result["items"] = from_list(lambda x: to_class(SkillServerIntegrationListResponseItem, x), self.items)
         return result
 
 
-class IntegrationSlackListStreamItemData:
+class SkillServerIntegrationListStreamItemData:
     """Blueprint properties"""
 
-    allow_from: Optional[str]
-    """Restrict which Slack users or channels can interact with this integration. Accepts Slack
-    user IDs (U…/W…), channel IDs (C…/G…/D…), @username, or
-    """
-    auto_respond: Optional[str]
-    """Configure automatic response behavior. Use '@all' to respond to all messages, '@agent
-    <instructions>' for agent-powered decisions, or custom instructions for lightweight LLM
-    filtering. Null/empty defaults to current behavior (DMs, mentions, threads only).
-    """
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: Optional[str]
-    """The ID of the bot this configuration is using"""
-
-    bot_token: Optional[str]
-    """The bot token (returned as '********' if configured, null otherwise)"""
-
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
@@ -27127,84 +27388,43 @@ class IntegrationSlackListStreamItemData:
     name: Optional[str]
     """The associated name"""
 
-    ratings: Optional[bool]
-    """Whether to enable ratings buttons feature"""
-
-    references: Optional[bool]
-    """Whether to enable references feature"""
-
-    session_duration: Optional[float]
-    """The session duration for the Slack integration"""
-
-    signing_secret: Optional[str]
-    """The signing secret (returned as '********' if configured, null otherwise)"""
+    skillset_id: Optional[str]
+    """The ID of the skillset"""
 
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    user_token: Optional[str]
-    """The user token (returned as '********' if configured, null otherwise)"""
-
-    visible_messages: Optional[float]
-    """The number of visible messages outside of the new thread"""
-
-    def __init__(self, allow_from: Optional[str], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], ratings: Optional[bool], references: Optional[bool], session_duration: Optional[float], signing_secret: Optional[str], updated_at: float, user_token: Optional[str], visible_messages: Optional[float]) -> None:
-        self.allow_from = allow_from
-        self.auto_respond = auto_respond
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], skillset_id: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
-        self.bot_id = bot_id
-        self.bot_token = bot_token
-        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
         self.id = id
         self.meta = meta
         self.name = name
-        self.ratings = ratings
-        self.references = references
-        self.session_duration = session_duration
-        self.signing_secret = signing_secret
+        self.skillset_id = skillset_id
         self.updated_at = updated_at
-        self.user_token = user_token
-        self.visible_messages = visible_messages
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackListStreamItemData':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationListStreamItemData':
         assert isinstance(obj, dict)
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
-        bot_token = from_union([from_str, from_none], obj.get("botToken"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        ratings = from_union([from_bool, from_none], obj.get("ratings"))
-        references = from_union([from_bool, from_none], obj.get("references"))
-        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        signing_secret = from_union([from_str, from_none], obj.get("signingSecret"))
+        skillset_id = from_union([from_str, from_none], obj.get("skillsetId"))
         updated_at = from_float(obj.get("updatedAt"))
-        user_token = from_union([from_str, from_none], obj.get("userToken"))
-        visible_messages = from_union([from_float, from_none], obj.get("visibleMessages"))
-        return IntegrationSlackListStreamItemData(allow_from, auto_respond, blueprint_id, bot_id, bot_token, contact_collection, created_at, description, id, meta, name, ratings, references, session_duration, signing_secret, updated_at, user_token, visible_messages)
+        return SkillServerIntegrationListStreamItemData(alias, blueprint_id, created_at, description, id, meta, name, skillset_id, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.auto_respond is not None:
-            result["autoRespond"] = from_union([from_str, from_none], self.auto_respond)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.bot_token is not None:
-            result["botToken"] = from_union([from_str, from_none], self.bot_token)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
@@ -27213,84 +27433,74 @@ def to_dict(self) -> dict:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.ratings is not None:
-            result["ratings"] = from_union([from_bool, from_none], self.ratings)
-        if self.references is not None:
-            result["references"] = from_union([from_bool, from_none], self.references)
-        if self.session_duration is not None:
-            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.signing_secret is not None:
-            result["signingSecret"] = from_union([from_str, from_none], self.signing_secret)
+        if self.skillset_id is not None:
+            result["skillsetId"] = from_union([from_str, from_none], self.skillset_id)
         result["updatedAt"] = to_float(self.updated_at)
-        if self.user_token is not None:
-            result["userToken"] = from_union([from_str, from_none], self.user_token)
-        if self.visible_messages is not None:
-            result["visibleMessages"] = from_union([to_float, from_none], self.visible_messages)
         return result
 
 
-class IntegrationSlackListStreamItemType(Enum):
+class SkillServerIntegrationListStreamItemType(Enum):
     """The type of event"""
 
     ITEM = "item"
 
 
-class IntegrationSlackListStreamItem:
-    data: IntegrationSlackListStreamItemData
+class SkillServerIntegrationListStreamItem:
+    data: SkillServerIntegrationListStreamItemData
     """Blueprint properties"""
 
-    type: IntegrationSlackListStreamItemType
+    type: SkillServerIntegrationListStreamItemType
     """The type of event"""
 
-    def __init__(self, data: IntegrationSlackListStreamItemData, type: IntegrationSlackListStreamItemType) -> None:
+    def __init__(self, data: SkillServerIntegrationListStreamItemData, type: SkillServerIntegrationListStreamItemType) -> None:
         self.data = data
         self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSlackListStreamItem':
+    def from_dict(obj: Any) -> 'SkillServerIntegrationListStreamItem':
         assert isinstance(obj, dict)
-        data = IntegrationSlackListStreamItemData.from_dict(obj.get("data"))
-        type = IntegrationSlackListStreamItemType(obj.get("type"))
-        return IntegrationSlackListStreamItem(data, type)
+        data = SkillServerIntegrationListStreamItemData.from_dict(obj.get("data"))
+        type = SkillServerIntegrationListStreamItemType(obj.get("type"))
+        return SkillServerIntegrationListStreamItem(data, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["data"] = to_class(IntegrationSlackListStreamItemData, self.data)
-        result["type"] = to_enum(IntegrationSlackListStreamItemType, self.type)
+        result["data"] = to_class(SkillServerIntegrationListStreamItemData, self.data)
+        result["type"] = to_enum(SkillServerIntegrationListStreamItemType, self.type)
         return result
 
 
-class IntegrationSupportDeleteParams:
-    support_integration_id: str
-    """The ID of the Support integration"""
+class IntegrationSlackDeleteParams:
+    slack_integration_id: str
+    """The ID of the Slack integration"""
 
-    def __init__(self, support_integration_id: str) -> None:
-        self.support_integration_id = support_integration_id
+    def __init__(self, slack_integration_id: str) -> None:
+        self.slack_integration_id = slack_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportDeleteParams':
+    def from_dict(obj: Any) -> 'IntegrationSlackDeleteParams':
         assert isinstance(obj, dict)
-        support_integration_id = from_str(obj.get("supportIntegrationId"))
-        return IntegrationSupportDeleteParams(support_integration_id)
+        slack_integration_id = from_str(obj.get("slackIntegrationId"))
+        return IntegrationSlackDeleteParams(slack_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["supportIntegrationId"] = from_str(self.support_integration_id)
+        result["slackIntegrationId"] = from_str(self.slack_integration_id)
         return result
 
 
-class IntegrationSupportDeleteResponse:
+class IntegrationSlackDeleteResponse:
     id: str
-    """The ID of the deleted Support integration"""
+    """The ID of the deleted Slack integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportDeleteResponse':
+    def from_dict(obj: Any) -> 'IntegrationSlackDeleteResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationSupportDeleteResponse(id)
+        return IntegrationSlackDeleteResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -27298,43 +27508,58 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationSupportFetchParams:
-    support_integration_id: str
-    """The ID of the Support integration to retrieve"""
+class IntegrationSlackFetchParams:
+    slack_integration_id: str
+    """The ID of the Slack integration to retrieve"""
 
-    def __init__(self, support_integration_id: str) -> None:
-        self.support_integration_id = support_integration_id
+    def __init__(self, slack_integration_id: str) -> None:
+        self.slack_integration_id = slack_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportFetchParams':
+    def from_dict(obj: Any) -> 'IntegrationSlackFetchParams':
         assert isinstance(obj, dict)
-        support_integration_id = from_str(obj.get("supportIntegrationId"))
-        return IntegrationSupportFetchParams(support_integration_id)
+        slack_integration_id = from_str(obj.get("slackIntegrationId"))
+        return IntegrationSlackFetchParams(slack_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["supportIntegrationId"] = from_str(self.support_integration_id)
+        result["slackIntegrationId"] = from_str(self.slack_integration_id)
         return result
 
 
-class IntegrationSupportFetchResponse:
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class IntegrationSlackFetchResponse:
+    """Blueprint properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
+    allow_from: Optional[str]
+    """Restrict which Slack users or channels can interact with this integration. Accepts Slack
+    user IDs (U…/W…), channel IDs (C…/G…/D…), @username, or
+    """
+    auto_respond: Optional[str]
+    """Configure automatic response behavior. Use '@all' to respond to all messages, '@agent
+    <instructions>' for agent-powered decisions, or custom instructions for lightweight LLM
+    filtering. Null/empty defaults to current behavior (DMs, mentions, threads only).
+    """
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: str
+    bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
+    bot_token: Optional[str]
+    """The bot token (returned as '********' if configured, null otherwise)"""
+
+    contact_collection: Optional[bool]
+    """Weather to collect contacts"""
+
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
     description: Optional[str]
     """The associated description"""
 
-    email: Optional[str]
-    """The email to use"""
-
     id: str
     """The instance ID"""
 
@@ -27344,212 +27569,311 @@ class IntegrationSupportFetchResponse:
     name: Optional[str]
     """The associated name"""
 
+    ratings: Optional[bool]
+    """Whether to enable ratings buttons feature"""
+
+    references: Optional[bool]
+    """Whether to enable references feature"""
+
+    session_duration: Optional[float]
+    """The session duration for the Slack integration"""
+
+    signing_secret: Optional[str]
+    """The signing secret (returned as '********' if configured, null otherwise)"""
+
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: str, created_at: float, description: Optional[str], email: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float) -> None:
+    user_token: Optional[str]
+    """The user token (returned as '********' if configured, null otherwise)"""
+
+    visible_messages: Optional[float]
+    """The number of visible messages outside of the new thread"""
+
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], ratings: Optional[bool], references: Optional[bool], session_duration: Optional[float], signing_secret: Optional[str], updated_at: float, user_token: Optional[str], visible_messages: Optional[float]) -> None:
+        self.alias = alias
+        self.allow_from = allow_from
+        self.auto_respond = auto_respond
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
+        self.bot_token = bot_token
+        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
-        self.email = email
         self.id = id
         self.meta = meta
         self.name = name
+        self.ratings = ratings
+        self.references = references
+        self.session_duration = session_duration
+        self.signing_secret = signing_secret
         self.updated_at = updated_at
+        self.user_token = user_token
+        self.visible_messages = visible_messages
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportFetchResponse':
+    def from_dict(obj: Any) -> 'IntegrationSlackFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_str(obj.get("botId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        bot_token = from_union([from_str, from_none], obj.get("botToken"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
-        email = from_union([from_str, from_none], obj.get("email"))
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
+        ratings = from_union([from_bool, from_none], obj.get("ratings"))
+        references = from_union([from_bool, from_none], obj.get("references"))
+        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        signing_secret = from_union([from_str, from_none], obj.get("signingSecret"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationSupportFetchResponse(blueprint_id, bot_id, created_at, description, email, id, meta, name, updated_at)
+        user_token = from_union([from_str, from_none], obj.get("userToken"))
+        visible_messages = from_union([from_float, from_none], obj.get("visibleMessages"))
+        return IntegrationSlackFetchResponse(alias, allow_from, auto_respond, blueprint_id, bot_id, bot_token, contact_collection, created_at, description, id, meta, name, ratings, references, session_duration, signing_secret, updated_at, user_token, visible_messages)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.auto_respond is not None:
+            result["autoRespond"] = from_union([from_str, from_none], self.auto_respond)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        result["botId"] = from_str(self.bot_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.bot_token is not None:
+            result["botToken"] = from_union([from_str, from_none], self.bot_token)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
-        if self.email is not None:
-            result["email"] = from_union([from_str, from_none], self.email)
         result["id"] = from_str(self.id)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.ratings is not None:
+            result["ratings"] = from_union([from_bool, from_none], self.ratings)
+        if self.references is not None:
+            result["references"] = from_union([from_bool, from_none], self.references)
+        if self.session_duration is not None:
+            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.signing_secret is not None:
+            result["signingSecret"] = from_union([from_str, from_none], self.signing_secret)
         result["updatedAt"] = to_float(self.updated_at)
+        if self.user_token is not None:
+            result["userToken"] = from_union([from_str, from_none], self.user_token)
+        if self.visible_messages is not None:
+            result["visibleMessages"] = from_union([to_float, from_none], self.visible_messages)
         return result
 
 
-class IntegrationSupportTriggerParams:
-    support_integration_id: str
-    """The ID of the Support integration"""
-
-    def __init__(self, support_integration_id: str) -> None:
-        self.support_integration_id = support_integration_id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportTriggerParams':
-        assert isinstance(obj, dict)
-        support_integration_id = from_str(obj.get("supportIntegrationId"))
-        return IntegrationSupportTriggerParams(support_integration_id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["supportIntegrationId"] = from_str(self.support_integration_id)
-        return result
-
-
-class IntegrationSupportTriggerRequest:
-    conversation_ids: Optional[List[str]]
-    """Array of conversation IDs to process"""
-
-    sample: Optional[int]
-    """Number of recent conversations to process (default 20)"""
+class IntegrationSlackSetupParams:
+    slack_integration_id: str
+    """The ID of the Slack integration"""
 
-    def __init__(self, conversation_ids: Optional[List[str]], sample: Optional[int]) -> None:
-        self.conversation_ids = conversation_ids
-        self.sample = sample
+    def __init__(self, slack_integration_id: str) -> None:
+        self.slack_integration_id = slack_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportTriggerRequest':
+    def from_dict(obj: Any) -> 'IntegrationSlackSetupParams':
         assert isinstance(obj, dict)
-        conversation_ids = from_union([lambda x: from_list(from_str, x), from_none], obj.get("conversationIds"))
-        sample = from_union([from_int, from_none], obj.get("sample"))
-        return IntegrationSupportTriggerRequest(conversation_ids, sample)
+        slack_integration_id = from_str(obj.get("slackIntegrationId"))
+        return IntegrationSlackSetupParams(slack_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.conversation_ids is not None:
-            result["conversationIds"] = from_union([lambda x: from_list(from_str, x), from_none], self.conversation_ids)
-        if self.sample is not None:
-            result["sample"] = from_union([from_int, from_none], self.sample)
+        result["slackIntegrationId"] = from_str(self.slack_integration_id)
         return result
 
 
-class IntegrationSupportTriggerResponse:
+class IntegrationSlackSetupResponse:
     id: str
-    """ID of the support integration"""
-
-    triggered: float
-    """Number of conversations queued for processing"""
+    """The ID of the setup Slack integration"""
 
-    def __init__(self, id: str, triggered: float) -> None:
+    def __init__(self, id: str) -> None:
         self.id = id
-        self.triggered = triggered
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportTriggerResponse':
+    def from_dict(obj: Any) -> 'IntegrationSlackSetupResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        triggered = from_float(obj.get("triggered"))
-        return IntegrationSupportTriggerResponse(id, triggered)
+        return IntegrationSlackSetupResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["id"] = from_str(self.id)
-        result["triggered"] = to_float(self.triggered)
         return result
 
 
-class IntegrationSupportUpdateParams:
-    support_integration_id: str
-    """The ID of the Support integration"""
+class IntegrationSlackUpdateParams:
+    slack_integration_id: str
+    """The ID of the Slack integration"""
 
-    def __init__(self, support_integration_id: str) -> None:
-        self.support_integration_id = support_integration_id
+    def __init__(self, slack_integration_id: str) -> None:
+        self.slack_integration_id = slack_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportUpdateParams':
+    def from_dict(obj: Any) -> 'IntegrationSlackUpdateParams':
         assert isinstance(obj, dict)
-        support_integration_id = from_str(obj.get("supportIntegrationId"))
-        return IntegrationSupportUpdateParams(support_integration_id)
+        slack_integration_id = from_str(obj.get("slackIntegrationId"))
+        return IntegrationSlackUpdateParams(slack_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["supportIntegrationId"] = from_str(self.support_integration_id)
+        result["slackIntegrationId"] = from_str(self.slack_integration_id)
         return result
 
 
-class IntegrationSupportUpdateRequest:
+class IntegrationSlackUpdateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    allow_from: Optional[str]
+    """Restrict which Slack users or channels can interact with this integration. Accepts Slack
+    user IDs (U…/W…), channel IDs (C…/G…/D…), @username, or
+    """
+    auto_respond: Optional[str]
+    """Configure automatic response behavior. Use '@all' to respond to all messages, '@agent
+    <instructions>' for agent-powered decisions, or custom instructions for lightweight LLM
+    filtering. Null/empty defaults to current behavior (DMs, mentions, threads only).
+    """
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
+    bot_token: Optional[str]
+    """The bot token for the Slack integration"""
+
+    contact_collection: Optional[bool]
+    """Weather to collect contacts"""
+
     description: Optional[str]
     """The associated description"""
 
-    email: Optional[str]
-    """The email to use"""
-
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], email: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str]) -> None:
+    ratings: Optional[bool]
+    """Whether to enable ratings buttons feature"""
+
+    references: Optional[bool]
+    """Whether to enable references feature"""
+
+    session_duration: Optional[float]
+    """The session duration for the Slack integration"""
+
+    signing_secret: Optional[str]
+    """The signing secret for the Slack integration"""
+
+    user_token: Optional[str]
+    """The user token for the Slack integration"""
+
+    visible_messages: Optional[float]
+    """The number of visible messages outside of the new thread"""
+
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], ratings: Optional[bool], references: Optional[bool], session_duration: Optional[float], signing_secret: Optional[str], user_token: Optional[str], visible_messages: Optional[float]) -> None:
+        self.alias = alias
+        self.allow_from = allow_from
+        self.auto_respond = auto_respond
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
+        self.bot_token = bot_token
+        self.contact_collection = contact_collection
         self.description = description
-        self.email = email
         self.meta = meta
         self.name = name
+        self.ratings = ratings
+        self.references = references
+        self.session_duration = session_duration
+        self.signing_secret = signing_secret
+        self.user_token = user_token
+        self.visible_messages = visible_messages
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportUpdateRequest':
+    def from_dict(obj: Any) -> 'IntegrationSlackUpdateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
+        bot_token = from_union([from_str, from_none], obj.get("botToken"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
-        email = from_union([from_str, from_none], obj.get("email"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        return IntegrationSupportUpdateRequest(blueprint_id, bot_id, description, email, meta, name)
+        ratings = from_union([from_bool, from_none], obj.get("ratings"))
+        references = from_union([from_bool, from_none], obj.get("references"))
+        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        signing_secret = from_union([from_str, from_none], obj.get("signingSecret"))
+        user_token = from_union([from_str, from_none], obj.get("userToken"))
+        visible_messages = from_union([from_float, from_none], obj.get("visibleMessages"))
+        return IntegrationSlackUpdateRequest(alias, allow_from, auto_respond, blueprint_id, bot_id, bot_token, contact_collection, description, meta, name, ratings, references, session_duration, signing_secret, user_token, visible_messages)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.description is not None:
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.auto_respond is not None:
+            result["autoRespond"] = from_union([from_str, from_none], self.auto_respond)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.bot_token is not None:
+            result["botToken"] = from_union([from_str, from_none], self.bot_token)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
+        if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
-        if self.email is not None:
-            result["email"] = from_union([from_str, from_none], self.email)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.ratings is not None:
+            result["ratings"] = from_union([from_bool, from_none], self.ratings)
+        if self.references is not None:
+            result["references"] = from_union([from_bool, from_none], self.references)
+        if self.session_duration is not None:
+            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.signing_secret is not None:
+            result["signingSecret"] = from_union([from_str, from_none], self.signing_secret)
+        if self.user_token is not None:
+            result["userToken"] = from_union([from_str, from_none], self.user_token)
+        if self.visible_messages is not None:
+            result["visibleMessages"] = from_union([to_float, from_none], self.visible_messages)
         return result
 
 
-class IntegrationSupportUpdateResponse:
+class IntegrationSlackUpdateResponse:
     id: str
-    """The ID of the Support Integration"""
+    """The ID of the Slack Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportUpdateResponse':
+    def from_dict(obj: Any) -> 'IntegrationSlackUpdateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationSupportUpdateResponse(id)
+        return IntegrationSlackUpdateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -27557,75 +27881,148 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationSupportCreateRequest:
+class IntegrationSlackCreateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    allow_from: Optional[str]
+    """Restrict which Slack users or channels can interact with this integration. Accepts Slack
+    user IDs (U…/W…), channel IDs (C…/G…/D…), @username, or
+    """
+    auto_respond: Optional[str]
+    """Configure automatic response behavior. Use '@all' to respond to all messages, '@agent
+    <instructions>' for agent-powered decisions, or custom instructions for lightweight LLM
+    filtering. Null/empty defaults to current behavior (DMs, mentions, threads only).
+    """
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
+    bot_token: Optional[str]
+    """The bot token for the Slack integration"""
+
+    contact_collection: Optional[bool]
+    """Weather to collect contacts"""
+
     description: Optional[str]
     """The associated description"""
 
-    email: Optional[str]
-    """The email to use"""
-
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], email: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str]) -> None:
+    ratings: Optional[bool]
+    """Whether to enable ratings buttons feature"""
+
+    references: Optional[bool]
+    """Whether to enable references feature"""
+
+    session_duration: Optional[float]
+    """The session duration for the Slack integration"""
+
+    signing_secret: Optional[str]
+    """The signing secret for the Slack integration"""
+
+    user_token: Optional[str]
+    """The user token for the Slack integration"""
+
+    visible_messages: Optional[float]
+    """The number of visible messages outside of the new thread"""
+
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], ratings: Optional[bool], references: Optional[bool], session_duration: Optional[float], signing_secret: Optional[str], user_token: Optional[str], visible_messages: Optional[float]) -> None:
+        self.alias = alias
+        self.allow_from = allow_from
+        self.auto_respond = auto_respond
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
+        self.bot_token = bot_token
+        self.contact_collection = contact_collection
         self.description = description
-        self.email = email
         self.meta = meta
         self.name = name
+        self.ratings = ratings
+        self.references = references
+        self.session_duration = session_duration
+        self.signing_secret = signing_secret
+        self.user_token = user_token
+        self.visible_messages = visible_messages
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportCreateRequest':
+    def from_dict(obj: Any) -> 'IntegrationSlackCreateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
+        bot_token = from_union([from_str, from_none], obj.get("botToken"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
-        email = from_union([from_str, from_none], obj.get("email"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        return IntegrationSupportCreateRequest(blueprint_id, bot_id, description, email, meta, name)
+        ratings = from_union([from_bool, from_none], obj.get("ratings"))
+        references = from_union([from_bool, from_none], obj.get("references"))
+        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        signing_secret = from_union([from_str, from_none], obj.get("signingSecret"))
+        user_token = from_union([from_str, from_none], obj.get("userToken"))
+        visible_messages = from_union([from_float, from_none], obj.get("visibleMessages"))
+        return IntegrationSlackCreateRequest(alias, allow_from, auto_respond, blueprint_id, bot_id, bot_token, contact_collection, description, meta, name, ratings, references, session_duration, signing_secret, user_token, visible_messages)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.auto_respond is not None:
+            result["autoRespond"] = from_union([from_str, from_none], self.auto_respond)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.bot_token is not None:
+            result["botToken"] = from_union([from_str, from_none], self.bot_token)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
-        if self.email is not None:
-            result["email"] = from_union([from_str, from_none], self.email)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.ratings is not None:
+            result["ratings"] = from_union([from_bool, from_none], self.ratings)
+        if self.references is not None:
+            result["references"] = from_union([from_bool, from_none], self.references)
+        if self.session_duration is not None:
+            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.signing_secret is not None:
+            result["signingSecret"] = from_union([from_str, from_none], self.signing_secret)
+        if self.user_token is not None:
+            result["userToken"] = from_union([from_str, from_none], self.user_token)
+        if self.visible_messages is not None:
+            result["visibleMessages"] = from_union([to_float, from_none], self.visible_messages)
         return result
 
 
-class IntegrationSupportCreateResponse:
+class IntegrationSlackCreateResponse:
     id: str
-    """The ID of the Support Integration"""
+    """The ID of the Slack Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportCreateResponse':
+    def from_dict(obj: Any) -> 'IntegrationSlackCreateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationSupportCreateResponse(id)
+        return IntegrationSlackCreateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -27633,40 +28030,40 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationSupportListParamsOrder(Enum):
+class IntegrationSlackListParamsOrder(Enum):
     """The order of the paginated items"""
 
     ASC = "asc"
     DESC = "desc"
 
 
-class IntegrationSupportListParams:
+class IntegrationSlackListParams:
     cursor: Optional[str]
     """The cursor to use for pagination"""
 
     meta: Optional[Dict[str, str]]
     """Key-value pairs to filter the partner users by metadata"""
 
-    order: Optional[IntegrationSupportListParamsOrder]
+    order: Optional[IntegrationSlackListParamsOrder]
     """The order of the paginated items"""
 
     take: Optional[int]
     """The number of items to retrieve"""
 
-    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[IntegrationSupportListParamsOrder], take: Optional[int]) -> None:
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[IntegrationSlackListParamsOrder], take: Optional[int]) -> None:
         self.cursor = cursor
         self.meta = meta
         self.order = order
         self.take = take
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportListParams':
+    def from_dict(obj: Any) -> 'IntegrationSlackListParams':
         assert isinstance(obj, dict)
         cursor = from_union([from_str, from_none], obj.get("cursor"))
         meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
-        order = from_union([IntegrationSupportListParamsOrder, from_none], obj.get("order"))
+        order = from_union([IntegrationSlackListParamsOrder, from_none], obj.get("order"))
         take = from_union([from_int, from_none], obj.get("take"))
-        return IntegrationSupportListParams(cursor, meta, order, take)
+        return IntegrationSlackListParams(cursor, meta, order, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -27675,30 +28072,45 @@ def to_dict(self) -> dict:
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
         if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(IntegrationSupportListParamsOrder, x), from_none], self.order)
+            result["order"] = from_union([lambda x: to_enum(IntegrationSlackListParamsOrder, x), from_none], self.order)
         if self.take is not None:
             result["take"] = from_union([from_int, from_none], self.take)
         return result
 
 
-class IntegrationSupportListResponseItem:
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class IntegrationSlackListResponseItem:
+    """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    allow_from: Optional[str]
+    """Restrict which Slack users or channels can interact with this integration. Accepts Slack
+    user IDs (U…/W…), channel IDs (C…/G…/D…), @username, or
+    """
+    auto_respond: Optional[str]
+    """Configure automatic response behavior. Use '@all' to respond to all messages, '@agent
+    <instructions>' for agent-powered decisions, or custom instructions for lightweight LLM
+    filtering. Null/empty defaults to current behavior (DMs, mentions, threads only).
+    """
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: str
+    bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
+    bot_token: Optional[str]
+    """The bot token (returned as '********' if configured, null otherwise)"""
+
+    contact_collection: Optional[bool]
+    """Weather to collect contacts"""
+
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
     description: Optional[str]
     """The associated description"""
 
-    email: Optional[str]
-    """The email to use"""
-
     id: str
     """The instance ID"""
 
@@ -27708,95 +28120,169 @@ class IntegrationSupportListResponseItem:
     name: Optional[str]
     """The associated name"""
 
+    ratings: Optional[bool]
+    """Whether to enable ratings buttons feature"""
+
+    references: Optional[bool]
+    """Whether to enable references feature"""
+
+    session_duration: Optional[float]
+    """The session duration for the Slack integration"""
+
+    signing_secret: Optional[str]
+    """The signing secret (returned as '********' if configured, null otherwise)"""
+
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: str, created_at: float, description: Optional[str], email: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float) -> None:
+    user_token: Optional[str]
+    """The user token (returned as '********' if configured, null otherwise)"""
+
+    visible_messages: Optional[float]
+    """The number of visible messages outside of the new thread"""
+
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], ratings: Optional[bool], references: Optional[bool], session_duration: Optional[float], signing_secret: Optional[str], updated_at: float, user_token: Optional[str], visible_messages: Optional[float]) -> None:
+        self.alias = alias
+        self.allow_from = allow_from
+        self.auto_respond = auto_respond
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
+        self.bot_token = bot_token
+        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
-        self.email = email
         self.id = id
         self.meta = meta
         self.name = name
+        self.ratings = ratings
+        self.references = references
+        self.session_duration = session_duration
+        self.signing_secret = signing_secret
         self.updated_at = updated_at
+        self.user_token = user_token
+        self.visible_messages = visible_messages
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportListResponseItem':
+    def from_dict(obj: Any) -> 'IntegrationSlackListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_str(obj.get("botId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        bot_token = from_union([from_str, from_none], obj.get("botToken"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
-        email = from_union([from_str, from_none], obj.get("email"))
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
+        ratings = from_union([from_bool, from_none], obj.get("ratings"))
+        references = from_union([from_bool, from_none], obj.get("references"))
+        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        signing_secret = from_union([from_str, from_none], obj.get("signingSecret"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationSupportListResponseItem(blueprint_id, bot_id, created_at, description, email, id, meta, name, updated_at)
+        user_token = from_union([from_str, from_none], obj.get("userToken"))
+        visible_messages = from_union([from_float, from_none], obj.get("visibleMessages"))
+        return IntegrationSlackListResponseItem(alias, allow_from, auto_respond, blueprint_id, bot_id, bot_token, contact_collection, created_at, description, id, meta, name, ratings, references, session_duration, signing_secret, updated_at, user_token, visible_messages)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.auto_respond is not None:
+            result["autoRespond"] = from_union([from_str, from_none], self.auto_respond)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        result["botId"] = from_str(self.bot_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.bot_token is not None:
+            result["botToken"] = from_union([from_str, from_none], self.bot_token)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
-        if self.email is not None:
-            result["email"] = from_union([from_str, from_none], self.email)
         result["id"] = from_str(self.id)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.ratings is not None:
+            result["ratings"] = from_union([from_bool, from_none], self.ratings)
+        if self.references is not None:
+            result["references"] = from_union([from_bool, from_none], self.references)
+        if self.session_duration is not None:
+            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.signing_secret is not None:
+            result["signingSecret"] = from_union([from_str, from_none], self.signing_secret)
         result["updatedAt"] = to_float(self.updated_at)
+        if self.user_token is not None:
+            result["userToken"] = from_union([from_str, from_none], self.user_token)
+        if self.visible_messages is not None:
+            result["visibleMessages"] = from_union([to_float, from_none], self.visible_messages)
         return result
 
 
-class IntegrationSupportListResponse:
+class IntegrationSlackListResponse:
     cursor: str
     """Cursor for fetching the next page"""
 
-    items: List[IntegrationSupportListResponseItem]
+    items: List[IntegrationSlackListResponseItem]
 
-    def __init__(self, cursor: str, items: List[IntegrationSupportListResponseItem]) -> None:
+    def __init__(self, cursor: str, items: List[IntegrationSlackListResponseItem]) -> None:
         self.cursor = cursor
         self.items = items
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportListResponse':
+    def from_dict(obj: Any) -> 'IntegrationSlackListResponse':
         assert isinstance(obj, dict)
         cursor = from_str(obj.get("cursor"))
-        items = from_list(IntegrationSupportListResponseItem.from_dict, obj.get("items"))
-        return IntegrationSupportListResponse(cursor, items)
+        items = from_list(IntegrationSlackListResponseItem.from_dict, obj.get("items"))
+        return IntegrationSlackListResponse(cursor, items)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["cursor"] = from_str(self.cursor)
-        result["items"] = from_list(lambda x: to_class(IntegrationSupportListResponseItem, x), self.items)
+        result["items"] = from_list(lambda x: to_class(IntegrationSlackListResponseItem, x), self.items)
         return result
 
 
-class IntegrationSupportListStreamItemData:
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class IntegrationSlackListStreamItemData:
+    """Blueprint properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
+    allow_from: Optional[str]
+    """Restrict which Slack users or channels can interact with this integration. Accepts Slack
+    user IDs (U…/W…), channel IDs (C…/G…/D…), @username, or
+    """
+    auto_respond: Optional[str]
+    """Configure automatic response behavior. Use '@all' to respond to all messages, '@agent
+    <instructions>' for agent-powered decisions, or custom instructions for lightweight LLM
+    filtering. Null/empty defaults to current behavior (DMs, mentions, threads only).
+    """
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: str
+    bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
+    bot_token: Optional[str]
+    """The bot token (returned as '********' if configured, null otherwise)"""
+
+    contact_collection: Optional[bool]
+    """Weather to collect contacts"""
+
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
     description: Optional[str]
     """The associated description"""
 
-    email: Optional[str]
-    """The email to use"""
-
     id: str
     """The instance ID"""
 
@@ -27806,115 +28292,174 @@ class IntegrationSupportListStreamItemData:
     name: Optional[str]
     """The associated name"""
 
+    ratings: Optional[bool]
+    """Whether to enable ratings buttons feature"""
+
+    references: Optional[bool]
+    """Whether to enable references feature"""
+
+    session_duration: Optional[float]
+    """The session duration for the Slack integration"""
+
+    signing_secret: Optional[str]
+    """The signing secret (returned as '********' if configured, null otherwise)"""
+
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: str, created_at: float, description: Optional[str], email: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float) -> None:
+    user_token: Optional[str]
+    """The user token (returned as '********' if configured, null otherwise)"""
+
+    visible_messages: Optional[float]
+    """The number of visible messages outside of the new thread"""
+
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], auto_respond: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], ratings: Optional[bool], references: Optional[bool], session_duration: Optional[float], signing_secret: Optional[str], updated_at: float, user_token: Optional[str], visible_messages: Optional[float]) -> None:
+        self.alias = alias
+        self.allow_from = allow_from
+        self.auto_respond = auto_respond
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
+        self.bot_token = bot_token
+        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
-        self.email = email
         self.id = id
         self.meta = meta
         self.name = name
+        self.ratings = ratings
+        self.references = references
+        self.session_duration = session_duration
+        self.signing_secret = signing_secret
         self.updated_at = updated_at
+        self.user_token = user_token
+        self.visible_messages = visible_messages
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportListStreamItemData':
+    def from_dict(obj: Any) -> 'IntegrationSlackListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        auto_respond = from_union([from_str, from_none], obj.get("autoRespond"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_str(obj.get("botId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        bot_token = from_union([from_str, from_none], obj.get("botToken"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
-        email = from_union([from_str, from_none], obj.get("email"))
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
+        ratings = from_union([from_bool, from_none], obj.get("ratings"))
+        references = from_union([from_bool, from_none], obj.get("references"))
+        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        signing_secret = from_union([from_str, from_none], obj.get("signingSecret"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationSupportListStreamItemData(blueprint_id, bot_id, created_at, description, email, id, meta, name, updated_at)
+        user_token = from_union([from_str, from_none], obj.get("userToken"))
+        visible_messages = from_union([from_float, from_none], obj.get("visibleMessages"))
+        return IntegrationSlackListStreamItemData(alias, allow_from, auto_respond, blueprint_id, bot_id, bot_token, contact_collection, created_at, description, id, meta, name, ratings, references, session_duration, signing_secret, updated_at, user_token, visible_messages)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.auto_respond is not None:
+            result["autoRespond"] = from_union([from_str, from_none], self.auto_respond)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        result["botId"] = from_str(self.bot_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.bot_token is not None:
+            result["botToken"] = from_union([from_str, from_none], self.bot_token)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
-        if self.email is not None:
-            result["email"] = from_union([from_str, from_none], self.email)
         result["id"] = from_str(self.id)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.ratings is not None:
+            result["ratings"] = from_union([from_bool, from_none], self.ratings)
+        if self.references is not None:
+            result["references"] = from_union([from_bool, from_none], self.references)
+        if self.session_duration is not None:
+            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.signing_secret is not None:
+            result["signingSecret"] = from_union([from_str, from_none], self.signing_secret)
         result["updatedAt"] = to_float(self.updated_at)
+        if self.user_token is not None:
+            result["userToken"] = from_union([from_str, from_none], self.user_token)
+        if self.visible_messages is not None:
+            result["visibleMessages"] = from_union([to_float, from_none], self.visible_messages)
         return result
 
 
-class IntegrationSupportListStreamItemType(Enum):
+class IntegrationSlackListStreamItemType(Enum):
     """The type of event"""
 
     ITEM = "item"
 
 
-class IntegrationSupportListStreamItem:
-    data: IntegrationSupportListStreamItemData
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class IntegrationSlackListStreamItem:
+    data: IntegrationSlackListStreamItemData
+    """Blueprint properties"""
 
-    type: IntegrationSupportListStreamItemType
+    type: IntegrationSlackListStreamItemType
     """The type of event"""
 
-    def __init__(self, data: IntegrationSupportListStreamItemData, type: IntegrationSupportListStreamItemType) -> None:
+    def __init__(self, data: IntegrationSlackListStreamItemData, type: IntegrationSlackListStreamItemType) -> None:
         self.data = data
         self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationSupportListStreamItem':
+    def from_dict(obj: Any) -> 'IntegrationSlackListStreamItem':
         assert isinstance(obj, dict)
-        data = IntegrationSupportListStreamItemData.from_dict(obj.get("data"))
-        type = IntegrationSupportListStreamItemType(obj.get("type"))
-        return IntegrationSupportListStreamItem(data, type)
+        data = IntegrationSlackListStreamItemData.from_dict(obj.get("data"))
+        type = IntegrationSlackListStreamItemType(obj.get("type"))
+        return IntegrationSlackListStreamItem(data, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["data"] = to_class(IntegrationSupportListStreamItemData, self.data)
-        result["type"] = to_enum(IntegrationSupportListStreamItemType, self.type)
+        result["data"] = to_class(IntegrationSlackListStreamItemData, self.data)
+        result["type"] = to_enum(IntegrationSlackListStreamItemType, self.type)
         return result
 
 
-class IntegrationTelegramDeleteParams:
-    telegram_integration_id: str
-    """The ID of the Telegram integration"""
+class IntegrationSupportDeleteParams:
+    support_integration_id: str
+    """The ID of the Support integration"""
 
-    def __init__(self, telegram_integration_id: str) -> None:
-        self.telegram_integration_id = telegram_integration_id
+    def __init__(self, support_integration_id: str) -> None:
+        self.support_integration_id = support_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramDeleteParams':
+    def from_dict(obj: Any) -> 'IntegrationSupportDeleteParams':
         assert isinstance(obj, dict)
-        telegram_integration_id = from_str(obj.get("telegramIntegrationId"))
-        return IntegrationTelegramDeleteParams(telegram_integration_id)
+        support_integration_id = from_str(obj.get("supportIntegrationId"))
+        return IntegrationSupportDeleteParams(support_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["telegramIntegrationId"] = from_str(self.telegram_integration_id)
+        result["supportIntegrationId"] = from_str(self.support_integration_id)
         return result
 
 
-class IntegrationTelegramDeleteResponse:
+class IntegrationSupportDeleteResponse:
     id: str
-    """The ID of the deleted Telegram integration"""
+    """The ID of the deleted Support integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramDeleteResponse':
+    def from_dict(obj: Any) -> 'IntegrationSupportDeleteResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationTelegramDeleteResponse(id)
+        return IntegrationSupportDeleteResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -27922,49 +28467,46 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationTelegramFetchParams:
-    telegram_integration_id: str
-    """The ID of the Telegram integration to retrieve"""
+class IntegrationSupportFetchParams:
+    support_integration_id: str
+    """The ID of the Support integration to retrieve"""
 
-    def __init__(self, telegram_integration_id: str) -> None:
-        self.telegram_integration_id = telegram_integration_id
+    def __init__(self, support_integration_id: str) -> None:
+        self.support_integration_id = support_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramFetchParams':
+    def from_dict(obj: Any) -> 'IntegrationSupportFetchParams':
         assert isinstance(obj, dict)
-        telegram_integration_id = from_str(obj.get("telegramIntegrationId"))
-        return IntegrationTelegramFetchParams(telegram_integration_id)
+        support_integration_id = from_str(obj.get("supportIntegrationId"))
+        return IntegrationSupportFetchParams(support_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["telegramIntegrationId"] = from_str(self.telegram_integration_id)
+        result["supportIntegrationId"] = from_str(self.support_integration_id)
         return result
 
 
-class IntegrationTelegramFetchResponse:
-    """Blueprint properties"""
-
-    allow_from: Optional[str]
-    """Newline-or-comma-separated list of allowed senders"""
+class IntegrationSupportFetchResponse:
+    """A bot configuration that can be applied without a dedicated bot instance."""
 
-    attachments: Optional[bool]
-    """Weather the bot supports attachments"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: Optional[str]
+    bot_id: str
     """The ID of the bot this configuration is using"""
 
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
     description: Optional[str]
     """The associated description"""
 
+    email: Optional[str]
+    """The email to use"""
+
     id: str
     """The instance ID"""
 
@@ -27974,134 +28516,152 @@ class IntegrationTelegramFetchResponse:
     name: Optional[str]
     """The associated name"""
 
-    session_duration: Optional[float]
-    """The session duration (in milliseconds)"""
-
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
-        self.allow_from = allow_from
-        self.attachments = attachments
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: str, created_at: float, description: Optional[str], email: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
+        self.email = email
         self.id = id
         self.meta = meta
         self.name = name
-        self.session_duration = session_duration
         self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramFetchResponse':
+    def from_dict(obj: Any) -> 'IntegrationSupportFetchResponse':
         assert isinstance(obj, dict)
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        attachments = from_union([from_bool, from_none], obj.get("attachments"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
+        bot_id = from_str(obj.get("botId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
+        email = from_union([from_str, from_none], obj.get("email"))
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationTelegramFetchResponse(allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
+        return IntegrationSupportFetchResponse(alias, blueprint_id, bot_id, created_at, description, email, id, meta, name, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.attachments is not None:
-            result["attachments"] = from_union([from_bool, from_none], self.attachments)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
+        result["botId"] = from_str(self.bot_id)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
+        if self.email is not None:
+            result["email"] = from_union([from_str, from_none], self.email)
         result["id"] = from_str(self.id)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.session_duration is not None:
-            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
         result["updatedAt"] = to_float(self.updated_at)
         return result
 
 
-class IntegrationTelegramSetupParams:
-    telegram_integration_id: str
-    """The ID of the Telegram integration"""
+class IntegrationSupportTriggerParams:
+    support_integration_id: str
+    """The ID of the Support integration"""
 
-    def __init__(self, telegram_integration_id: str) -> None:
-        self.telegram_integration_id = telegram_integration_id
+    def __init__(self, support_integration_id: str) -> None:
+        self.support_integration_id = support_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramSetupParams':
+    def from_dict(obj: Any) -> 'IntegrationSupportTriggerParams':
         assert isinstance(obj, dict)
-        telegram_integration_id = from_str(obj.get("telegramIntegrationId"))
-        return IntegrationTelegramSetupParams(telegram_integration_id)
+        support_integration_id = from_str(obj.get("supportIntegrationId"))
+        return IntegrationSupportTriggerParams(support_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["telegramIntegrationId"] = from_str(self.telegram_integration_id)
+        result["supportIntegrationId"] = from_str(self.support_integration_id)
         return result
 
 
-class IntegrationTelegramSetupResponse:
-    id: str
-    """The ID of the Telegram Integration"""
+class IntegrationSupportTriggerRequest:
+    conversation_ids: Optional[List[str]]
+    """Array of conversation IDs to process"""
 
-    def __init__(self, id: str) -> None:
+    sample: Optional[int]
+    """Number of recent conversations to process (default 20)"""
+
+    def __init__(self, conversation_ids: Optional[List[str]], sample: Optional[int]) -> None:
+        self.conversation_ids = conversation_ids
+        self.sample = sample
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationSupportTriggerRequest':
+        assert isinstance(obj, dict)
+        conversation_ids = from_union([lambda x: from_list(from_str, x), from_none], obj.get("conversationIds"))
+        sample = from_union([from_int, from_none], obj.get("sample"))
+        return IntegrationSupportTriggerRequest(conversation_ids, sample)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.conversation_ids is not None:
+            result["conversationIds"] = from_union([lambda x: from_list(from_str, x), from_none], self.conversation_ids)
+        if self.sample is not None:
+            result["sample"] = from_union([from_int, from_none], self.sample)
+        return result
+
+
+class IntegrationSupportTriggerResponse:
+    id: str
+    """ID of the support integration"""
+
+    triggered: float
+    """Number of conversations queued for processing"""
+
+    def __init__(self, id: str, triggered: float) -> None:
         self.id = id
+        self.triggered = triggered
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramSetupResponse':
+    def from_dict(obj: Any) -> 'IntegrationSupportTriggerResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationTelegramSetupResponse(id)
+        triggered = from_float(obj.get("triggered"))
+        return IntegrationSupportTriggerResponse(id, triggered)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["id"] = from_str(self.id)
+        result["triggered"] = to_float(self.triggered)
         return result
 
 
-class IntegrationTelegramUpdateParams:
-    telegram_integration_id: str
-    """The ID of the Telegram integration"""
+class IntegrationSupportUpdateParams:
+    support_integration_id: str
+    """The ID of the Support integration"""
 
-    def __init__(self, telegram_integration_id: str) -> None:
-        self.telegram_integration_id = telegram_integration_id
+    def __init__(self, support_integration_id: str) -> None:
+        self.support_integration_id = support_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramUpdateParams':
+    def from_dict(obj: Any) -> 'IntegrationSupportUpdateParams':
         assert isinstance(obj, dict)
-        telegram_integration_id = from_str(obj.get("telegramIntegrationId"))
-        return IntegrationTelegramUpdateParams(telegram_integration_id)
+        support_integration_id = from_str(obj.get("supportIntegrationId"))
+        return IntegrationSupportUpdateParams(support_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["telegramIntegrationId"] = from_str(self.telegram_integration_id)
+        result["supportIntegrationId"] = from_str(self.support_integration_id)
         return result
 
 
-class IntegrationTelegramUpdateRequest:
+class IntegrationSupportUpdateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
-    allow_from: Optional[str]
-    """Newline-or-comma-separated list of allowed senders. Use @username or @numericId for users,"""
-
-    attachments: Optional[bool]
-    """Weather the bot supports attachments"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -28109,88 +28669,70 @@ class IntegrationTelegramUpdateRequest:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
-    bot_token: Optional[str]
-    """The Telegram integration bot token"""
-
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     description: Optional[str]
     """The associated description"""
 
+    email: Optional[str]
+    """The email to use"""
+
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    session_duration: Optional[float]
-    """The session duration (in milliseconds)"""
-
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
-        self.allow_from = allow_from
-        self.attachments = attachments
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], email: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.bot_token = bot_token
-        self.contact_collection = contact_collection
         self.description = description
+        self.email = email
         self.meta = meta
         self.name = name
-        self.session_duration = session_duration
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramUpdateRequest':
+    def from_dict(obj: Any) -> 'IntegrationSupportUpdateRequest':
         assert isinstance(obj, dict)
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        attachments = from_union([from_bool, from_none], obj.get("attachments"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
-        bot_token = from_union([from_str, from_none], obj.get("botToken"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
+        email = from_union([from_str, from_none], obj.get("email"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return IntegrationTelegramUpdateRequest(allow_from, attachments, blueprint_id, bot_id, bot_token, contact_collection, description, meta, name, session_duration)
+        return IntegrationSupportUpdateRequest(alias, blueprint_id, bot_id, description, email, meta, name)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.attachments is not None:
-            result["attachments"] = from_union([from_bool, from_none], self.attachments)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.bot_token is not None:
-            result["botToken"] = from_union([from_str, from_none], self.bot_token)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
+        if self.email is not None:
+            result["email"] = from_union([from_str, from_none], self.email)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.session_duration is not None:
-            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
         return result
 
 
-class IntegrationTelegramUpdateResponse:
+class IntegrationSupportUpdateResponse:
     id: str
-    """The ID of the Telegram Integration"""
+    """The ID of the Support Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramUpdateResponse':
+    def from_dict(obj: Any) -> 'IntegrationSupportUpdateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationTelegramUpdateResponse(id)
+        return IntegrationSupportUpdateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -28198,14 +28740,11 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationTelegramCreateRequest:
+class IntegrationSupportCreateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
-    allow_from: Optional[str]
-    """Newline-or-comma-separated list of allowed senders. Use @username or @numericId for users,"""
-
-    attachments: Optional[bool]
-    """Weather the bot supports attachments"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -28213,88 +28752,70 @@ class IntegrationTelegramCreateRequest:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
-    bot_token: Optional[str]
-    """The Telegram integration bot token"""
-
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     description: Optional[str]
     """The associated description"""
 
+    email: Optional[str]
+    """The email to use"""
+
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    session_duration: Optional[float]
-    """The session duration (in milliseconds)"""
-
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
-        self.allow_from = allow_from
-        self.attachments = attachments
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], email: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.bot_token = bot_token
-        self.contact_collection = contact_collection
         self.description = description
+        self.email = email
         self.meta = meta
         self.name = name
-        self.session_duration = session_duration
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramCreateRequest':
+    def from_dict(obj: Any) -> 'IntegrationSupportCreateRequest':
         assert isinstance(obj, dict)
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        attachments = from_union([from_bool, from_none], obj.get("attachments"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
-        bot_token = from_union([from_str, from_none], obj.get("botToken"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
+        email = from_union([from_str, from_none], obj.get("email"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return IntegrationTelegramCreateRequest(allow_from, attachments, blueprint_id, bot_id, bot_token, contact_collection, description, meta, name, session_duration)
+        return IntegrationSupportCreateRequest(alias, blueprint_id, bot_id, description, email, meta, name)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.attachments is not None:
-            result["attachments"] = from_union([from_bool, from_none], self.attachments)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.bot_token is not None:
-            result["botToken"] = from_union([from_str, from_none], self.bot_token)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
+        if self.email is not None:
+            result["email"] = from_union([from_str, from_none], self.email)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.session_duration is not None:
-            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
         return result
 
 
-class IntegrationTelegramCreateResponse:
+class IntegrationSupportCreateResponse:
     id: str
-    """The ID of the Telegram Integration"""
+    """The ID of the Support Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramCreateResponse':
+    def from_dict(obj: Any) -> 'IntegrationSupportCreateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationTelegramCreateResponse(id)
+        return IntegrationSupportCreateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -28302,40 +28823,40 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationTelegramListParamsOrder(Enum):
+class IntegrationSupportListParamsOrder(Enum):
     """The order of the paginated items"""
 
     ASC = "asc"
     DESC = "desc"
 
 
-class IntegrationTelegramListParams:
+class IntegrationSupportListParams:
     cursor: Optional[str]
     """The cursor to use for pagination"""
 
     meta: Optional[Dict[str, str]]
     """Key-value pairs to filter the partner users by metadata"""
 
-    order: Optional[IntegrationTelegramListParamsOrder]
+    order: Optional[IntegrationSupportListParamsOrder]
     """The order of the paginated items"""
 
     take: Optional[int]
     """The number of items to retrieve"""
 
-    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[IntegrationTelegramListParamsOrder], take: Optional[int]) -> None:
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[IntegrationSupportListParamsOrder], take: Optional[int]) -> None:
         self.cursor = cursor
         self.meta = meta
         self.order = order
         self.take = take
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramListParams':
+    def from_dict(obj: Any) -> 'IntegrationSupportListParams':
         assert isinstance(obj, dict)
         cursor = from_union([from_str, from_none], obj.get("cursor"))
         meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
-        order = from_union([IntegrationTelegramListParamsOrder, from_none], obj.get("order"))
+        order = from_union([IntegrationSupportListParamsOrder, from_none], obj.get("order"))
         take = from_union([from_int, from_none], obj.get("take"))
-        return IntegrationTelegramListParams(cursor, meta, order, take)
+        return IntegrationSupportListParams(cursor, meta, order, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -28344,36 +28865,33 @@ def to_dict(self) -> dict:
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
         if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(IntegrationTelegramListParamsOrder, x), from_none], self.order)
+            result["order"] = from_union([lambda x: to_enum(IntegrationSupportListParamsOrder, x), from_none], self.order)
         if self.take is not None:
             result["take"] = from_union([from_int, from_none], self.take)
         return result
 
 
-class IntegrationTelegramListResponseItem:
-    """Blueprint properties"""
-
-    allow_from: Optional[str]
-    """Newline-or-comma-separated list of allowed senders. Use @username or @numericId for users,"""
+class IntegrationSupportListResponseItem:
+    """A bot configuration that can be applied without a dedicated bot instance."""
 
-    attachments: Optional[bool]
-    """Weather the bot supports attachments"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: Optional[str]
+    bot_id: str
     """The ID of the bot this configuration is using"""
 
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
     description: Optional[str]
     """The associated description"""
 
+    email: Optional[str]
+    """The email to use"""
+
     id: str
     """The instance ID"""
 
@@ -28383,117 +28901,102 @@ class IntegrationTelegramListResponseItem:
     name: Optional[str]
     """The associated name"""
 
-    session_duration: Optional[float]
-    """The session duration (in milliseconds)"""
-
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
-        self.allow_from = allow_from
-        self.attachments = attachments
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: str, created_at: float, description: Optional[str], email: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
+        self.email = email
         self.id = id
         self.meta = meta
         self.name = name
-        self.session_duration = session_duration
         self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramListResponseItem':
+    def from_dict(obj: Any) -> 'IntegrationSupportListResponseItem':
         assert isinstance(obj, dict)
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        attachments = from_union([from_bool, from_none], obj.get("attachments"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
+        bot_id = from_str(obj.get("botId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
+        email = from_union([from_str, from_none], obj.get("email"))
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationTelegramListResponseItem(allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
+        return IntegrationSupportListResponseItem(alias, blueprint_id, bot_id, created_at, description, email, id, meta, name, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.attachments is not None:
-            result["attachments"] = from_union([from_bool, from_none], self.attachments)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
+        result["botId"] = from_str(self.bot_id)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
+        if self.email is not None:
+            result["email"] = from_union([from_str, from_none], self.email)
         result["id"] = from_str(self.id)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.session_duration is not None:
-            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
         result["updatedAt"] = to_float(self.updated_at)
         return result
 
 
-class IntegrationTelegramListResponse:
+class IntegrationSupportListResponse:
     cursor: str
     """Cursor for fetching the next page"""
 
-    items: List[IntegrationTelegramListResponseItem]
+    items: List[IntegrationSupportListResponseItem]
 
-    def __init__(self, cursor: str, items: List[IntegrationTelegramListResponseItem]) -> None:
+    def __init__(self, cursor: str, items: List[IntegrationSupportListResponseItem]) -> None:
         self.cursor = cursor
         self.items = items
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramListResponse':
+    def from_dict(obj: Any) -> 'IntegrationSupportListResponse':
         assert isinstance(obj, dict)
         cursor = from_str(obj.get("cursor"))
-        items = from_list(IntegrationTelegramListResponseItem.from_dict, obj.get("items"))
-        return IntegrationTelegramListResponse(cursor, items)
+        items = from_list(IntegrationSupportListResponseItem.from_dict, obj.get("items"))
+        return IntegrationSupportListResponse(cursor, items)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["cursor"] = from_str(self.cursor)
-        result["items"] = from_list(lambda x: to_class(IntegrationTelegramListResponseItem, x), self.items)
+        result["items"] = from_list(lambda x: to_class(IntegrationSupportListResponseItem, x), self.items)
         return result
 
 
-class IntegrationTelegramListStreamItemData:
-    """Blueprint properties"""
-
-    allow_from: Optional[str]
-    """Newline-or-comma-separated list of allowed senders. Use @username or @numericId for users,"""
+class IntegrationSupportListStreamItemData:
+    """A bot configuration that can be applied without a dedicated bot instance."""
 
-    attachments: Optional[bool]
-    """Weather the bot supports attachments"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: Optional[str]
+    bot_id: str
     """The ID of the bot this configuration is using"""
 
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
     description: Optional[str]
     """The associated description"""
 
+    email: Optional[str]
+    """The email to use"""
+
     id: str
     """The instance ID"""
 
@@ -28503,131 +29006,119 @@ class IntegrationTelegramListStreamItemData:
     name: Optional[str]
     """The associated name"""
 
-    session_duration: Optional[float]
-    """The session duration (in milliseconds)"""
-
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
-        self.allow_from = allow_from
-        self.attachments = attachments
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: str, created_at: float, description: Optional[str], email: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
+        self.email = email
         self.id = id
         self.meta = meta
         self.name = name
-        self.session_duration = session_duration
         self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramListStreamItemData':
+    def from_dict(obj: Any) -> 'IntegrationSupportListStreamItemData':
         assert isinstance(obj, dict)
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        attachments = from_union([from_bool, from_none], obj.get("attachments"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
+        bot_id = from_str(obj.get("botId"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
+        email = from_union([from_str, from_none], obj.get("email"))
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        return IntegrationTelegramListStreamItemData(allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
+        return IntegrationSupportListStreamItemData(alias, blueprint_id, bot_id, created_at, description, email, id, meta, name, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.attachments is not None:
-            result["attachments"] = from_union([from_bool, from_none], self.attachments)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
+        result["botId"] = from_str(self.bot_id)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
+        if self.email is not None:
+            result["email"] = from_union([from_str, from_none], self.email)
         result["id"] = from_str(self.id)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.session_duration is not None:
-            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
         result["updatedAt"] = to_float(self.updated_at)
         return result
 
 
-class IntegrationTelegramListStreamItemType(Enum):
+class IntegrationSupportListStreamItemType(Enum):
     """The type of event"""
 
     ITEM = "item"
 
 
-class IntegrationTelegramListStreamItem:
-    data: IntegrationTelegramListStreamItemData
-    """Blueprint properties"""
+class IntegrationSupportListStreamItem:
+    data: IntegrationSupportListStreamItemData
+    """A bot configuration that can be applied without a dedicated bot instance."""
 
-    type: IntegrationTelegramListStreamItemType
+    type: IntegrationSupportListStreamItemType
     """The type of event"""
 
-    def __init__(self, data: IntegrationTelegramListStreamItemData, type: IntegrationTelegramListStreamItemType) -> None:
+    def __init__(self, data: IntegrationSupportListStreamItemData, type: IntegrationSupportListStreamItemType) -> None:
         self.data = data
         self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTelegramListStreamItem':
+    def from_dict(obj: Any) -> 'IntegrationSupportListStreamItem':
         assert isinstance(obj, dict)
-        data = IntegrationTelegramListStreamItemData.from_dict(obj.get("data"))
-        type = IntegrationTelegramListStreamItemType(obj.get("type"))
-        return IntegrationTelegramListStreamItem(data, type)
+        data = IntegrationSupportListStreamItemData.from_dict(obj.get("data"))
+        type = IntegrationSupportListStreamItemType(obj.get("type"))
+        return IntegrationSupportListStreamItem(data, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["data"] = to_class(IntegrationTelegramListStreamItemData, self.data)
-        result["type"] = to_enum(IntegrationTelegramListStreamItemType, self.type)
+        result["data"] = to_class(IntegrationSupportListStreamItemData, self.data)
+        result["type"] = to_enum(IntegrationSupportListStreamItemType, self.type)
         return result
 
 
-class TriggerIntegrationDeleteParams:
-    trigger_integration_id: str
-    """The ID of the Trigger integration"""
+class IntegrationTelegramDeleteParams:
+    telegram_integration_id: str
+    """The ID of the Telegram integration"""
 
-    def __init__(self, trigger_integration_id: str) -> None:
-        self.trigger_integration_id = trigger_integration_id
+    def __init__(self, telegram_integration_id: str) -> None:
+        self.telegram_integration_id = telegram_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationDeleteParams':
+    def from_dict(obj: Any) -> 'IntegrationTelegramDeleteParams':
         assert isinstance(obj, dict)
-        trigger_integration_id = from_str(obj.get("triggerIntegrationId"))
-        return TriggerIntegrationDeleteParams(trigger_integration_id)
+        telegram_integration_id = from_str(obj.get("telegramIntegrationId"))
+        return IntegrationTelegramDeleteParams(telegram_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["triggerIntegrationId"] = from_str(self.trigger_integration_id)
+        result["telegramIntegrationId"] = from_str(self.telegram_integration_id)
         return result
 
 
-class TriggerIntegrationDeleteResponse:
+class IntegrationTelegramDeleteResponse:
     id: str
-    """The ID of the deleted Trigger integration"""
+    """The ID of the deleted Telegram integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationDeleteResponse':
+    def from_dict(obj: Any) -> 'IntegrationTelegramDeleteResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return TriggerIntegrationDeleteResponse(id)
+        return IntegrationTelegramDeleteResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -28635,30 +29126,36 @@ def to_dict(self) -> dict:
         return result
 
 
-class TriggerIntegrationFetchParams:
-    trigger_integration_id: str
-    """The ID of the Trigger integration to retrieve"""
+class IntegrationTelegramFetchParams:
+    telegram_integration_id: str
+    """The ID of the Telegram integration to retrieve"""
 
-    def __init__(self, trigger_integration_id: str) -> None:
-        self.trigger_integration_id = trigger_integration_id
+    def __init__(self, telegram_integration_id: str) -> None:
+        self.telegram_integration_id = telegram_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationFetchParams':
+    def from_dict(obj: Any) -> 'IntegrationTelegramFetchParams':
         assert isinstance(obj, dict)
-        trigger_integration_id = from_str(obj.get("triggerIntegrationId"))
-        return TriggerIntegrationFetchParams(trigger_integration_id)
+        telegram_integration_id = from_str(obj.get("telegramIntegrationId"))
+        return IntegrationTelegramFetchParams(telegram_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["triggerIntegrationId"] = from_str(self.trigger_integration_id)
+        result["telegramIntegrationId"] = from_str(self.telegram_integration_id)
         return result
 
 
-class TriggerIntegrationFetchResponse:
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class IntegrationTelegramFetchResponse:
+    """Blueprint properties"""
 
-    authenticate: Optional[bool]
-    """When enabled the integration requires authentication"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    allow_from: Optional[str]
+    """Newline-or-comma-separated list of allowed senders"""
+
+    attachments: Optional[bool]
+    """Weather the bot supports attachments"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -28666,6 +29163,9 @@ class TriggerIntegrationFetchResponse:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
+    contact_collection: Optional[bool]
+    """Weather to collect contacts"""
+
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
@@ -28675,132 +29175,110 @@ class TriggerIntegrationFetchResponse:
     id: str
     """The instance ID"""
 
-    last_trigger_at: Optional[float]
-    """The timestamp (ms) of the last trigger execution"""
-
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    next_trigger_at: Optional[float]
-    """The timestamp (ms) of the next scheduled trigger execution"""
-
-    schedule: Optional[str]
-    """The schedule for the trigger integration (interval, cron expression, ISO date, or null)"""
-
-    secret: str
-    """The Trigger integration secret"""
-
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    timezone: Optional[str]
-    """The IANA timezone identifier used to evaluate the trigger schedule."""
-
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, authenticate: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: Optional[str], id: str, last_trigger_at: Optional[float], meta: Optional[Dict[str, Any]], name: Optional[str], next_trigger_at: Optional[float], schedule: Optional[str], secret: str, session_duration: Optional[float], timezone: Optional[str], updated_at: float) -> None:
-        self.authenticate = authenticate
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
+        self.allow_from = allow_from
+        self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
+        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
         self.id = id
-        self.last_trigger_at = last_trigger_at
         self.meta = meta
         self.name = name
-        self.next_trigger_at = next_trigger_at
-        self.schedule = schedule
-        self.secret = secret
         self.session_duration = session_duration
-        self.timezone = timezone
         self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationFetchResponse':
+    def from_dict(obj: Any) -> 'IntegrationTelegramFetchResponse':
         assert isinstance(obj, dict)
-        authenticate = from_union([from_bool, from_none], obj.get("authenticate"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
-        last_trigger_at = from_union([from_float, from_none], obj.get("lastTriggerAt"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        next_trigger_at = from_union([from_float, from_none], obj.get("nextTriggerAt"))
-        schedule = from_union([from_str, from_none], obj.get("schedule"))
-        secret = from_str(obj.get("secret"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        timezone = from_union([from_str, from_none], obj.get("timezone"))
         updated_at = from_float(obj.get("updatedAt"))
-        return TriggerIntegrationFetchResponse(authenticate, blueprint_id, bot_id, created_at, description, id, last_trigger_at, meta, name, next_trigger_at, schedule, secret, session_duration, timezone, updated_at)
+        return IntegrationTelegramFetchResponse(alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.authenticate is not None:
-            result["authenticate"] = from_union([from_bool, from_none], self.authenticate)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.attachments is not None:
+            result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         result["id"] = from_str(self.id)
-        if self.last_trigger_at is not None:
-            result["lastTriggerAt"] = from_union([to_float, from_none], self.last_trigger_at)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.next_trigger_at is not None:
-            result["nextTriggerAt"] = from_union([to_float, from_none], self.next_trigger_at)
-        if self.schedule is not None:
-            result["schedule"] = from_union([from_str, from_none], self.schedule)
-        result["secret"] = from_str(self.secret)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.timezone is not None:
-            result["timezone"] = from_union([from_str, from_none], self.timezone)
         result["updatedAt"] = to_float(self.updated_at)
         return result
 
 
-class TriggerIntegrationInvokeParams:
-    trigger_integration_id: str
-    """The ID of the Trigger integration"""
+class IntegrationTelegramSetupParams:
+    telegram_integration_id: str
+    """The ID of the Telegram integration"""
 
-    def __init__(self, trigger_integration_id: str) -> None:
-        self.trigger_integration_id = trigger_integration_id
+    def __init__(self, telegram_integration_id: str) -> None:
+        self.telegram_integration_id = telegram_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationInvokeParams':
+    def from_dict(obj: Any) -> 'IntegrationTelegramSetupParams':
         assert isinstance(obj, dict)
-        trigger_integration_id = from_str(obj.get("triggerIntegrationId"))
-        return TriggerIntegrationInvokeParams(trigger_integration_id)
+        telegram_integration_id = from_str(obj.get("telegramIntegrationId"))
+        return IntegrationTelegramSetupParams(telegram_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["triggerIntegrationId"] = from_str(self.trigger_integration_id)
+        result["telegramIntegrationId"] = from_str(self.telegram_integration_id)
         return result
 
 
-class TriggerIntegrationInvokeResponse:
+class IntegrationTelegramSetupResponse:
     id: str
-    """The ID of the trigged Trigger integration"""
+    """The ID of the Telegram Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationInvokeResponse':
+    def from_dict(obj: Any) -> 'IntegrationTelegramSetupResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return TriggerIntegrationInvokeResponse(id)
+        return IntegrationTelegramSetupResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -28808,68 +29286,36 @@ def to_dict(self) -> dict:
         return result
 
 
-class TriggerIntegrationSetupParams:
-    trigger_integration_id: str
-    """The ID of the Trigger integration"""
+class IntegrationTelegramUpdateParams:
+    telegram_integration_id: str
+    """The ID of the Telegram integration"""
 
-    def __init__(self, trigger_integration_id: str) -> None:
-        self.trigger_integration_id = trigger_integration_id
+    def __init__(self, telegram_integration_id: str) -> None:
+        self.telegram_integration_id = telegram_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationSetupParams':
+    def from_dict(obj: Any) -> 'IntegrationTelegramUpdateParams':
         assert isinstance(obj, dict)
-        trigger_integration_id = from_str(obj.get("triggerIntegrationId"))
-        return TriggerIntegrationSetupParams(trigger_integration_id)
+        telegram_integration_id = from_str(obj.get("telegramIntegrationId"))
+        return IntegrationTelegramUpdateParams(telegram_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["triggerIntegrationId"] = from_str(self.trigger_integration_id)
+        result["telegramIntegrationId"] = from_str(self.telegram_integration_id)
         return result
 
 
-class TriggerIntegrationSetupResponse:
-    id: str
-    """The ID of the Trigger Integration"""
+class IntegrationTelegramUpdateRequest:
+    """A bot configuration that can be applied without a dedicated bot instance."""
 
-    def __init__(self, id: str) -> None:
-        self.id = id
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
-    @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationSetupResponse':
-        assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
-        return TriggerIntegrationSetupResponse(id)
+    allow_from: Optional[str]
+    """Newline-or-comma-separated list of allowed senders. Use @username or @numericId for users,"""
 
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["id"] = from_str(self.id)
-        return result
-
-
-class TriggerIntegrationUpdateParams:
-    trigger_integration_id: str
-    """The ID of the Trigger integration"""
-
-    def __init__(self, trigger_integration_id: str) -> None:
-        self.trigger_integration_id = trigger_integration_id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationUpdateParams':
-        assert isinstance(obj, dict)
-        trigger_integration_id = from_str(obj.get("triggerIntegrationId"))
-        return TriggerIntegrationUpdateParams(trigger_integration_id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["triggerIntegrationId"] = from_str(self.trigger_integration_id)
-        return result
-
-
-class TriggerIntegrationUpdateRequest:
-    """A bot configuration that can be applied without a dedicated bot instance."""
-
-    authenticate: Optional[bool]
-    """When enabled the integration requires authentication"""
+    attachments: Optional[bool]
+    """Weather the bot supports attachments"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -28877,6 +29323,12 @@ class TriggerIntegrationUpdateRequest:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
+    bot_token: Optional[str]
+    """The Telegram integration bot token"""
+
+    contact_collection: Optional[bool]
+    """Weather to collect contacts"""
+
     description: Optional[str]
     """The associated description"""
 
@@ -28886,75 +29338,77 @@ class TriggerIntegrationUpdateRequest:
     name: Optional[str]
     """The associated name"""
 
-    schedule: Optional[str]
-    """The schedule for the trigger integration (interval, cron expression, or ISO date)"""
-
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    timezone: Optional[str]
-    """An optional IANA timezone identifier used when evaluating the trigger schedule."""
-
-    def __init__(self, authenticate: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], schedule: Optional[str], session_duration: Optional[float], timezone: Optional[str]) -> None:
-        self.authenticate = authenticate
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
+        self.alias = alias
+        self.allow_from = allow_from
+        self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
+        self.bot_token = bot_token
+        self.contact_collection = contact_collection
         self.description = description
         self.meta = meta
         self.name = name
-        self.schedule = schedule
         self.session_duration = session_duration
-        self.timezone = timezone
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationUpdateRequest':
+    def from_dict(obj: Any) -> 'IntegrationTelegramUpdateRequest':
         assert isinstance(obj, dict)
-        authenticate = from_union([from_bool, from_none], obj.get("authenticate"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
+        bot_token = from_union([from_str, from_none], obj.get("botToken"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        schedule = from_union([from_str, from_none], obj.get("schedule"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        timezone = from_union([from_str, from_none], obj.get("timezone"))
-        return TriggerIntegrationUpdateRequest(authenticate, blueprint_id, bot_id, description, meta, name, schedule, session_duration, timezone)
+        return IntegrationTelegramUpdateRequest(alias, allow_from, attachments, blueprint_id, bot_id, bot_token, contact_collection, description, meta, name, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.authenticate is not None:
-            result["authenticate"] = from_union([from_bool, from_none], self.authenticate)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.attachments is not None:
+            result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.bot_token is not None:
+            result["botToken"] = from_union([from_str, from_none], self.bot_token)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.schedule is not None:
-            result["schedule"] = from_union([from_str, from_none], self.schedule)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.timezone is not None:
-            result["timezone"] = from_union([from_str, from_none], self.timezone)
         return result
 
 
-class TriggerIntegrationUpdateResponse:
+class IntegrationTelegramUpdateResponse:
     id: str
-    """The ID of the Trigger Integration"""
+    """The ID of the Telegram Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationUpdateResponse':
+    def from_dict(obj: Any) -> 'IntegrationTelegramUpdateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return TriggerIntegrationUpdateResponse(id)
+        return IntegrationTelegramUpdateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -28962,11 +29416,17 @@ def to_dict(self) -> dict:
         return result
 
 
-class TriggerIntegrationCreateRequest:
+class IntegrationTelegramCreateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
-    authenticate: Optional[bool]
-    """When enabled the integration requires authentication"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    allow_from: Optional[str]
+    """Newline-or-comma-separated list of allowed senders. Use @username or @numericId for users,"""
+
+    attachments: Optional[bool]
+    """Weather the bot supports attachments"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -28974,6 +29434,12 @@ class TriggerIntegrationCreateRequest:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
+    bot_token: Optional[str]
+    """The Telegram integration bot token"""
+
+    contact_collection: Optional[bool]
+    """Weather to collect contacts"""
+
     description: Optional[str]
     """The associated description"""
 
@@ -28983,75 +29449,77 @@ class TriggerIntegrationCreateRequest:
     name: Optional[str]
     """The associated name"""
 
-    schedule: Optional[str]
-    """The schedule for the trigger integration (interval, cron expression, or ISO date)"""
-
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    timezone: Optional[str]
-    """An optional IANA timezone identifier used when evaluating the trigger schedule."""
-
-    def __init__(self, authenticate: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], schedule: Optional[str], session_duration: Optional[float], timezone: Optional[str]) -> None:
-        self.authenticate = authenticate
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], bot_token: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float]) -> None:
+        self.alias = alias
+        self.allow_from = allow_from
+        self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
+        self.bot_token = bot_token
+        self.contact_collection = contact_collection
         self.description = description
         self.meta = meta
         self.name = name
-        self.schedule = schedule
         self.session_duration = session_duration
-        self.timezone = timezone
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationCreateRequest':
+    def from_dict(obj: Any) -> 'IntegrationTelegramCreateRequest':
         assert isinstance(obj, dict)
-        authenticate = from_union([from_bool, from_none], obj.get("authenticate"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
+        bot_token = from_union([from_str, from_none], obj.get("botToken"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        schedule = from_union([from_str, from_none], obj.get("schedule"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        timezone = from_union([from_str, from_none], obj.get("timezone"))
-        return TriggerIntegrationCreateRequest(authenticate, blueprint_id, bot_id, description, meta, name, schedule, session_duration, timezone)
+        return IntegrationTelegramCreateRequest(alias, allow_from, attachments, blueprint_id, bot_id, bot_token, contact_collection, description, meta, name, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.authenticate is not None:
-            result["authenticate"] = from_union([from_bool, from_none], self.authenticate)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.attachments is not None:
+            result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.bot_token is not None:
+            result["botToken"] = from_union([from_str, from_none], self.bot_token)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.schedule is not None:
-            result["schedule"] = from_union([from_str, from_none], self.schedule)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.timezone is not None:
-            result["timezone"] = from_union([from_str, from_none], self.timezone)
         return result
 
 
-class TriggerIntegrationCreateResponse:
+class IntegrationTelegramCreateResponse:
     id: str
-    """The ID of the Trigger Integration"""
+    """The ID of the Telegram Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationCreateResponse':
+    def from_dict(obj: Any) -> 'IntegrationTelegramCreateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return TriggerIntegrationCreateResponse(id)
+        return IntegrationTelegramCreateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -29059,40 +29527,40 @@ def to_dict(self) -> dict:
         return result
 
 
-class TriggerIntegrationListParamsOrder(Enum):
+class IntegrationTelegramListParamsOrder(Enum):
     """The order of the paginated items"""
 
     ASC = "asc"
     DESC = "desc"
 
 
-class TriggerIntegrationListParams:
+class IntegrationTelegramListParams:
     cursor: Optional[str]
     """The cursor to use for pagination"""
 
     meta: Optional[Dict[str, str]]
     """Key-value pairs to filter the partner users by metadata"""
 
-    order: Optional[TriggerIntegrationListParamsOrder]
+    order: Optional[IntegrationTelegramListParamsOrder]
     """The order of the paginated items"""
 
     take: Optional[int]
     """The number of items to retrieve"""
 
-    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[TriggerIntegrationListParamsOrder], take: Optional[int]) -> None:
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[IntegrationTelegramListParamsOrder], take: Optional[int]) -> None:
         self.cursor = cursor
         self.meta = meta
         self.order = order
         self.take = take
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationListParams':
+    def from_dict(obj: Any) -> 'IntegrationTelegramListParams':
         assert isinstance(obj, dict)
         cursor = from_union([from_str, from_none], obj.get("cursor"))
         meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
-        order = from_union([TriggerIntegrationListParamsOrder, from_none], obj.get("order"))
+        order = from_union([IntegrationTelegramListParamsOrder, from_none], obj.get("order"))
         take = from_union([from_int, from_none], obj.get("take"))
-        return TriggerIntegrationListParams(cursor, meta, order, take)
+        return IntegrationTelegramListParams(cursor, meta, order, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -29101,17 +29569,23 @@ def to_dict(self) -> dict:
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
         if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(TriggerIntegrationListParamsOrder, x), from_none], self.order)
+            result["order"] = from_union([lambda x: to_enum(IntegrationTelegramListParamsOrder, x), from_none], self.order)
         if self.take is not None:
             result["take"] = from_union([from_int, from_none], self.take)
         return result
 
 
-class TriggerIntegrationListResponseItem:
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class IntegrationTelegramListResponseItem:
+    """Blueprint properties"""
 
-    authenticate: Optional[bool]
-    """When enabled the integration requires authentication"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    allow_from: Optional[str]
+    """Newline-or-comma-separated list of allowed senders. Use @username or @numericId for users,"""
+
+    attachments: Optional[bool]
+    """Weather the bot supports attachments"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -29119,6 +29593,9 @@ class TriggerIntegrationListResponseItem:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
+    contact_collection: Optional[bool]
+    """Weather to collect contacts"""
+
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
@@ -29128,130 +29605,114 @@ class TriggerIntegrationListResponseItem:
     id: str
     """The instance ID"""
 
-    last_trigger_at: Optional[float]
-    """The timestamp (ms) of the last trigger execution"""
-
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    next_trigger_at: Optional[float]
-    """The timestamp (ms) of the next scheduled trigger execution"""
-
-    schedule: Optional[str]
-    """The schedule for the trigger integration (interval, cron expression, ISO date, or null)"""
-
-    secret: str
-    """The Trigger integration secret"""
-
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    timezone: Optional[str]
-    """The IANA timezone identifier used to evaluate the trigger schedule."""
-
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, authenticate: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: Optional[str], id: str, last_trigger_at: Optional[float], meta: Optional[Dict[str, Any]], name: Optional[str], next_trigger_at: Optional[float], schedule: Optional[str], secret: str, session_duration: Optional[float], timezone: Optional[str], updated_at: float) -> None:
-        self.authenticate = authenticate
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
+        self.allow_from = allow_from
+        self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
+        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
         self.id = id
-        self.last_trigger_at = last_trigger_at
         self.meta = meta
         self.name = name
-        self.next_trigger_at = next_trigger_at
-        self.schedule = schedule
-        self.secret = secret
         self.session_duration = session_duration
-        self.timezone = timezone
         self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationListResponseItem':
+    def from_dict(obj: Any) -> 'IntegrationTelegramListResponseItem':
         assert isinstance(obj, dict)
-        authenticate = from_union([from_bool, from_none], obj.get("authenticate"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
-        last_trigger_at = from_union([from_float, from_none], obj.get("lastTriggerAt"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        next_trigger_at = from_union([from_float, from_none], obj.get("nextTriggerAt"))
-        schedule = from_union([from_str, from_none], obj.get("schedule"))
-        secret = from_str(obj.get("secret"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        timezone = from_union([from_str, from_none], obj.get("timezone"))
         updated_at = from_float(obj.get("updatedAt"))
-        return TriggerIntegrationListResponseItem(authenticate, blueprint_id, bot_id, created_at, description, id, last_trigger_at, meta, name, next_trigger_at, schedule, secret, session_duration, timezone, updated_at)
+        return IntegrationTelegramListResponseItem(alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.authenticate is not None:
-            result["authenticate"] = from_union([from_bool, from_none], self.authenticate)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.attachments is not None:
+            result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         result["id"] = from_str(self.id)
-        if self.last_trigger_at is not None:
-            result["lastTriggerAt"] = from_union([to_float, from_none], self.last_trigger_at)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.next_trigger_at is not None:
-            result["nextTriggerAt"] = from_union([to_float, from_none], self.next_trigger_at)
-        if self.schedule is not None:
-            result["schedule"] = from_union([from_str, from_none], self.schedule)
-        result["secret"] = from_str(self.secret)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.timezone is not None:
-            result["timezone"] = from_union([from_str, from_none], self.timezone)
         result["updatedAt"] = to_float(self.updated_at)
         return result
 
 
-class TriggerIntegrationListResponse:
+class IntegrationTelegramListResponse:
     cursor: str
     """Cursor for fetching the next page"""
 
-    items: List[TriggerIntegrationListResponseItem]
+    items: List[IntegrationTelegramListResponseItem]
 
-    def __init__(self, cursor: str, items: List[TriggerIntegrationListResponseItem]) -> None:
+    def __init__(self, cursor: str, items: List[IntegrationTelegramListResponseItem]) -> None:
         self.cursor = cursor
         self.items = items
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationListResponse':
+    def from_dict(obj: Any) -> 'IntegrationTelegramListResponse':
         assert isinstance(obj, dict)
         cursor = from_str(obj.get("cursor"))
-        items = from_list(TriggerIntegrationListResponseItem.from_dict, obj.get("items"))
-        return TriggerIntegrationListResponse(cursor, items)
+        items = from_list(IntegrationTelegramListResponseItem.from_dict, obj.get("items"))
+        return IntegrationTelegramListResponse(cursor, items)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["cursor"] = from_str(self.cursor)
-        result["items"] = from_list(lambda x: to_class(TriggerIntegrationListResponseItem, x), self.items)
+        result["items"] = from_list(lambda x: to_class(IntegrationTelegramListResponseItem, x), self.items)
         return result
 
 
-class TriggerIntegrationListStreamItemData:
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class IntegrationTelegramListStreamItemData:
+    """Blueprint properties"""
 
-    authenticate: Optional[bool]
-    """When enabled the integration requires authentication"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    allow_from: Optional[str]
+    """Newline-or-comma-separated list of allowed senders. Use @username or @numericId for users,"""
+
+    attachments: Optional[bool]
+    """Weather the bot supports attachments"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -29259,6 +29720,9 @@ class TriggerIntegrationListStreamItemData:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
+    contact_collection: Optional[bool]
+    """Weather to collect contacts"""
+
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
@@ -29268,163 +29732,141 @@ class TriggerIntegrationListStreamItemData:
     id: str
     """The instance ID"""
 
-    last_trigger_at: Optional[float]
-    """The timestamp (ms) of the last trigger execution"""
-
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    next_trigger_at: Optional[float]
-    """The timestamp (ms) of the next scheduled trigger execution"""
-
-    schedule: Optional[str]
-    """The schedule for the trigger integration (interval, cron expression, ISO date, or null)"""
-
-    secret: str
-    """The Trigger integration secret"""
-
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    timezone: Optional[str]
-    """The IANA timezone identifier used to evaluate the trigger schedule."""
-
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, authenticate: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: Optional[str], id: str, last_trigger_at: Optional[float], meta: Optional[Dict[str, Any]], name: Optional[str], next_trigger_at: Optional[float], schedule: Optional[str], secret: str, session_duration: Optional[float], timezone: Optional[str], updated_at: float) -> None:
-        self.authenticate = authenticate
+    def __init__(self, alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float) -> None:
+        self.alias = alias
+        self.allow_from = allow_from
+        self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
+        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
         self.id = id
-        self.last_trigger_at = last_trigger_at
         self.meta = meta
         self.name = name
-        self.next_trigger_at = next_trigger_at
-        self.schedule = schedule
-        self.secret = secret
         self.session_duration = session_duration
-        self.timezone = timezone
         self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationListStreamItemData':
+    def from_dict(obj: Any) -> 'IntegrationTelegramListStreamItemData':
         assert isinstance(obj, dict)
-        authenticate = from_union([from_bool, from_none], obj.get("authenticate"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
-        last_trigger_at = from_union([from_float, from_none], obj.get("lastTriggerAt"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        next_trigger_at = from_union([from_float, from_none], obj.get("nextTriggerAt"))
-        schedule = from_union([from_str, from_none], obj.get("schedule"))
-        secret = from_str(obj.get("secret"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        timezone = from_union([from_str, from_none], obj.get("timezone"))
         updated_at = from_float(obj.get("updatedAt"))
-        return TriggerIntegrationListStreamItemData(authenticate, blueprint_id, bot_id, created_at, description, id, last_trigger_at, meta, name, next_trigger_at, schedule, secret, session_duration, timezone, updated_at)
+        return IntegrationTelegramListStreamItemData(alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.authenticate is not None:
-            result["authenticate"] = from_union([from_bool, from_none], self.authenticate)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.attachments is not None:
+            result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         result["id"] = from_str(self.id)
-        if self.last_trigger_at is not None:
-            result["lastTriggerAt"] = from_union([to_float, from_none], self.last_trigger_at)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.next_trigger_at is not None:
-            result["nextTriggerAt"] = from_union([to_float, from_none], self.next_trigger_at)
-        if self.schedule is not None:
-            result["schedule"] = from_union([from_str, from_none], self.schedule)
-        result["secret"] = from_str(self.secret)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.timezone is not None:
-            result["timezone"] = from_union([from_str, from_none], self.timezone)
         result["updatedAt"] = to_float(self.updated_at)
         return result
 
 
-class TriggerIntegrationListStreamItemType(Enum):
+class IntegrationTelegramListStreamItemType(Enum):
     """The type of event"""
 
     ITEM = "item"
 
 
-class TriggerIntegrationListStreamItem:
-    data: TriggerIntegrationListStreamItemData
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class IntegrationTelegramListStreamItem:
+    data: IntegrationTelegramListStreamItemData
+    """Blueprint properties"""
 
-    type: TriggerIntegrationListStreamItemType
+    type: IntegrationTelegramListStreamItemType
     """The type of event"""
 
-    def __init__(self, data: TriggerIntegrationListStreamItemData, type: TriggerIntegrationListStreamItemType) -> None:
+    def __init__(self, data: IntegrationTelegramListStreamItemData, type: IntegrationTelegramListStreamItemType) -> None:
         self.data = data
         self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'TriggerIntegrationListStreamItem':
+    def from_dict(obj: Any) -> 'IntegrationTelegramListStreamItem':
         assert isinstance(obj, dict)
-        data = TriggerIntegrationListStreamItemData.from_dict(obj.get("data"))
-        type = TriggerIntegrationListStreamItemType(obj.get("type"))
-        return TriggerIntegrationListStreamItem(data, type)
+        data = IntegrationTelegramListStreamItemData.from_dict(obj.get("data"))
+        type = IntegrationTelegramListStreamItemType(obj.get("type"))
+        return IntegrationTelegramListStreamItem(data, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["data"] = to_class(TriggerIntegrationListStreamItemData, self.data)
-        result["type"] = to_enum(TriggerIntegrationListStreamItemType, self.type)
+        result["data"] = to_class(IntegrationTelegramListStreamItemData, self.data)
+        result["type"] = to_enum(IntegrationTelegramListStreamItemType, self.type)
         return result
 
 
-class IntegrationTwilioDeleteParams:
-    twilio_integration_id: str
-    """The ID of the Twilio integration"""
+class TriggerIntegrationDeleteParams:
+    trigger_integration_id: str
+    """The ID of the Trigger integration"""
 
-    def __init__(self, twilio_integration_id: str) -> None:
-        self.twilio_integration_id = twilio_integration_id
+    def __init__(self, trigger_integration_id: str) -> None:
+        self.trigger_integration_id = trigger_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioDeleteParams':
+    def from_dict(obj: Any) -> 'TriggerIntegrationDeleteParams':
         assert isinstance(obj, dict)
-        twilio_integration_id = from_str(obj.get("twilioIntegrationId"))
-        return IntegrationTwilioDeleteParams(twilio_integration_id)
+        trigger_integration_id = from_str(obj.get("triggerIntegrationId"))
+        return TriggerIntegrationDeleteParams(trigger_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["twilioIntegrationId"] = from_str(self.twilio_integration_id)
+        result["triggerIntegrationId"] = from_str(self.trigger_integration_id)
         return result
 
 
-class IntegrationTwilioDeleteResponse:
+class TriggerIntegrationDeleteResponse:
     id: str
-    """The ID of the deleted Twilio integration"""
+    """The ID of the deleted Trigger integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioDeleteResponse':
+    def from_dict(obj: Any) -> 'TriggerIntegrationDeleteResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationTwilioDeleteResponse(id)
+        return TriggerIntegrationDeleteResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -29432,33 +29874,33 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationTwilioFetchParams:
-    twilio_integration_id: str
-    """The ID of the Twilio integration to retrieve"""
+class TriggerIntegrationFetchParams:
+    trigger_integration_id: str
+    """The ID of the Trigger integration to retrieve"""
 
-    def __init__(self, twilio_integration_id: str) -> None:
-        self.twilio_integration_id = twilio_integration_id
+    def __init__(self, trigger_integration_id: str) -> None:
+        self.trigger_integration_id = trigger_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioFetchParams':
+    def from_dict(obj: Any) -> 'TriggerIntegrationFetchParams':
         assert isinstance(obj, dict)
-        twilio_integration_id = from_str(obj.get("twilioIntegrationId"))
-        return IntegrationTwilioFetchParams(twilio_integration_id)
+        trigger_integration_id = from_str(obj.get("triggerIntegrationId"))
+        return TriggerIntegrationFetchParams(trigger_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["twilioIntegrationId"] = from_str(self.twilio_integration_id)
+        result["triggerIntegrationId"] = from_str(self.trigger_integration_id)
         return result
 
 
-class IntegrationTwilioFetchResponse:
-    """Blueprint properties"""
+class TriggerIntegrationFetchResponse:
+    """A bot configuration that can be applied without a dedicated bot instance."""
 
-    account_sid: Optional[str]
-    """The Twilio account SID"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
-    allow_from: Optional[str]
-    """Newline-or-comma-separated list of allowed senders"""
+    authenticate: Optional[bool]
+    """When enabled the integration requires authentication"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -29466,9 +29908,6 @@ class IntegrationTwilioFetchResponse:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
@@ -29478,113 +29917,136 @@ class IntegrationTwilioFetchResponse:
     id: str
     """The instance ID"""
 
+    last_trigger_at: Optional[float]
+    """The timestamp (ms) of the last trigger execution"""
+
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
+    next_trigger_at: Optional[float]
+    """The timestamp (ms) of the next scheduled trigger execution"""
+
+    schedule: Optional[str]
+    """The schedule for the trigger integration (interval, cron expression, ISO date, or null)"""
+
+    secret: str
+    """The Trigger integration secret"""
+
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
+    timezone: Optional[str]
+    """The IANA timezone identifier used to evaluate the trigger schedule."""
+
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    voice: Optional[str]
-    """The voice configuration structured string"""
-
-    def __init__(self, account_sid: Optional[str], allow_from: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, voice: Optional[str]) -> None:
-        self.account_sid = account_sid
-        self.allow_from = allow_from
+    def __init__(self, alias: Optional[str], authenticate: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: Optional[str], id: str, last_trigger_at: Optional[float], meta: Optional[Dict[str, Any]], name: Optional[str], next_trigger_at: Optional[float], schedule: Optional[str], secret: str, session_duration: Optional[float], timezone: Optional[str], updated_at: float) -> None:
+        self.alias = alias
+        self.authenticate = authenticate
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
         self.id = id
+        self.last_trigger_at = last_trigger_at
         self.meta = meta
         self.name = name
+        self.next_trigger_at = next_trigger_at
+        self.schedule = schedule
+        self.secret = secret
         self.session_duration = session_duration
+        self.timezone = timezone
         self.updated_at = updated_at
-        self.voice = voice
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioFetchResponse':
+    def from_dict(obj: Any) -> 'TriggerIntegrationFetchResponse':
         assert isinstance(obj, dict)
-        account_sid = from_union([from_str, from_none], obj.get("accountSid"))
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        authenticate = from_union([from_bool, from_none], obj.get("authenticate"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
+        last_trigger_at = from_union([from_float, from_none], obj.get("lastTriggerAt"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
+        next_trigger_at = from_union([from_float, from_none], obj.get("nextTriggerAt"))
+        schedule = from_union([from_str, from_none], obj.get("schedule"))
+        secret = from_str(obj.get("secret"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        timezone = from_union([from_str, from_none], obj.get("timezone"))
         updated_at = from_float(obj.get("updatedAt"))
-        voice = from_union([from_str, from_none], obj.get("voice"))
-        return IntegrationTwilioFetchResponse(account_sid, allow_from, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, voice)
+        return TriggerIntegrationFetchResponse(alias, authenticate, blueprint_id, bot_id, created_at, description, id, last_trigger_at, meta, name, next_trigger_at, schedule, secret, session_duration, timezone, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.account_sid is not None:
-            result["accountSid"] = from_union([from_str, from_none], self.account_sid)
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.authenticate is not None:
+            result["authenticate"] = from_union([from_bool, from_none], self.authenticate)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         result["id"] = from_str(self.id)
+        if self.last_trigger_at is not None:
+            result["lastTriggerAt"] = from_union([to_float, from_none], self.last_trigger_at)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.next_trigger_at is not None:
+            result["nextTriggerAt"] = from_union([to_float, from_none], self.next_trigger_at)
+        if self.schedule is not None:
+            result["schedule"] = from_union([from_str, from_none], self.schedule)
+        result["secret"] = from_str(self.secret)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.timezone is not None:
+            result["timezone"] = from_union([from_str, from_none], self.timezone)
         result["updatedAt"] = to_float(self.updated_at)
-        if self.voice is not None:
-            result["voice"] = from_union([from_str, from_none], self.voice)
         return result
 
 
-class IntegrationTwilioSetupParams:
-    twilio_integration_id: str
-    """The ID of the Twilio integration"""
+class TriggerIntegrationInvokeParams:
+    trigger_integration_id: str
+    """The ID of the Trigger integration"""
 
-    def __init__(self, twilio_integration_id: str) -> None:
-        self.twilio_integration_id = twilio_integration_id
+    def __init__(self, trigger_integration_id: str) -> None:
+        self.trigger_integration_id = trigger_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioSetupParams':
+    def from_dict(obj: Any) -> 'TriggerIntegrationInvokeParams':
         assert isinstance(obj, dict)
-        twilio_integration_id = from_str(obj.get("twilioIntegrationId"))
-        return IntegrationTwilioSetupParams(twilio_integration_id)
+        trigger_integration_id = from_str(obj.get("triggerIntegrationId"))
+        return TriggerIntegrationInvokeParams(trigger_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["twilioIntegrationId"] = from_str(self.twilio_integration_id)
+        result["triggerIntegrationId"] = from_str(self.trigger_integration_id)
         return result
 
 
-class IntegrationTwilioSetupResponse:
+class TriggerIntegrationInvokeResponse:
     id: str
-    """The ID of the Twilio Integration"""
+    """The ID of the trigged Trigger integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioSetupResponse':
+    def from_dict(obj: Any) -> 'TriggerIntegrationInvokeResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationTwilioSetupResponse(id)
+        return TriggerIntegrationInvokeResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -29592,37 +30054,71 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationTwilioUpdateParams:
-    twilio_integration_id: str
-    """The ID of the Twilio integration"""
+class TriggerIntegrationSetupParams:
+    trigger_integration_id: str
+    """The ID of the Trigger integration"""
 
-    def __init__(self, twilio_integration_id: str) -> None:
-        self.twilio_integration_id = twilio_integration_id
+    def __init__(self, trigger_integration_id: str) -> None:
+        self.trigger_integration_id = trigger_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioUpdateParams':
+    def from_dict(obj: Any) -> 'TriggerIntegrationSetupParams':
         assert isinstance(obj, dict)
-        twilio_integration_id = from_str(obj.get("twilioIntegrationId"))
-        return IntegrationTwilioUpdateParams(twilio_integration_id)
+        trigger_integration_id = from_str(obj.get("triggerIntegrationId"))
+        return TriggerIntegrationSetupParams(trigger_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["twilioIntegrationId"] = from_str(self.twilio_integration_id)
+        result["triggerIntegrationId"] = from_str(self.trigger_integration_id)
         return result
 
 
-class IntegrationTwilioUpdateRequest:
+class TriggerIntegrationSetupResponse:
+    id: str
+    """The ID of the Trigger Integration"""
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'TriggerIntegrationSetupResponse':
+        assert isinstance(obj, dict)
+        id = from_str(obj.get("id"))
+        return TriggerIntegrationSetupResponse(id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["id"] = from_str(self.id)
+        return result
+
+
+class TriggerIntegrationUpdateParams:
+    trigger_integration_id: str
+    """The ID of the Trigger integration"""
+
+    def __init__(self, trigger_integration_id: str) -> None:
+        self.trigger_integration_id = trigger_integration_id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'TriggerIntegrationUpdateParams':
+        assert isinstance(obj, dict)
+        trigger_integration_id = from_str(obj.get("triggerIntegrationId"))
+        return TriggerIntegrationUpdateParams(trigger_integration_id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["triggerIntegrationId"] = from_str(self.trigger_integration_id)
+        return result
+
+
+class TriggerIntegrationUpdateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
-    account_sid: Optional[str]
-    """The Twilio account SID"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
-    allow_from: Optional[str]
-    """Newline-or-comma-separated list of allowed senders. Use E.164 phone numbers with or
-    without the leading `+`. Set to `*` to allow all. Leave empty to deny all.
-    """
-    auth_token: Optional[str]
-    """The Twilio auth token"""
+    authenticate: Optional[bool]
+    """When enabled the integration requires authentication"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -29630,9 +30126,6 @@ class IntegrationTwilioUpdateRequest:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     description: Optional[str]
     """The associated description"""
 
@@ -29642,80 +30135,79 @@ class IntegrationTwilioUpdateRequest:
     name: Optional[str]
     """The associated name"""
 
+    schedule: Optional[str]
+    """The schedule for the trigger integration (interval, cron expression, or ISO date)"""
+
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    voice: Optional[str]
-    """The voice configuration structured string"""
+    timezone: Optional[str]
+    """An optional IANA timezone identifier used when evaluating the trigger schedule."""
 
-    def __init__(self, account_sid: Optional[str], allow_from: Optional[str], auth_token: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], voice: Optional[str]) -> None:
-        self.account_sid = account_sid
-        self.allow_from = allow_from
-        self.auth_token = auth_token
+    def __init__(self, alias: Optional[str], authenticate: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], schedule: Optional[str], session_duration: Optional[float], timezone: Optional[str]) -> None:
+        self.alias = alias
+        self.authenticate = authenticate
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.contact_collection = contact_collection
         self.description = description
         self.meta = meta
         self.name = name
+        self.schedule = schedule
         self.session_duration = session_duration
-        self.voice = voice
+        self.timezone = timezone
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioUpdateRequest':
+    def from_dict(obj: Any) -> 'TriggerIntegrationUpdateRequest':
         assert isinstance(obj, dict)
-        account_sid = from_union([from_str, from_none], obj.get("accountSid"))
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        auth_token = from_union([from_str, from_none], obj.get("authToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        authenticate = from_union([from_bool, from_none], obj.get("authenticate"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
+        schedule = from_union([from_str, from_none], obj.get("schedule"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        voice = from_union([from_str, from_none], obj.get("voice"))
-        return IntegrationTwilioUpdateRequest(account_sid, allow_from, auth_token, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration, voice)
+        timezone = from_union([from_str, from_none], obj.get("timezone"))
+        return TriggerIntegrationUpdateRequest(alias, authenticate, blueprint_id, bot_id, description, meta, name, schedule, session_duration, timezone)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.account_sid is not None:
-            result["accountSid"] = from_union([from_str, from_none], self.account_sid)
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.auth_token is not None:
-            result["authToken"] = from_union([from_str, from_none], self.auth_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.authenticate is not None:
+            result["authenticate"] = from_union([from_bool, from_none], self.authenticate)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.schedule is not None:
+            result["schedule"] = from_union([from_str, from_none], self.schedule)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.voice is not None:
-            result["voice"] = from_union([from_str, from_none], self.voice)
+        if self.timezone is not None:
+            result["timezone"] = from_union([from_str, from_none], self.timezone)
         return result
 
 
-class IntegrationTwilioUpdateResponse:
+class TriggerIntegrationUpdateResponse:
     id: str
-    """The ID of the Twilio Integration"""
+    """The ID of the Trigger Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioUpdateResponse':
+    def from_dict(obj: Any) -> 'TriggerIntegrationUpdateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationTwilioUpdateResponse(id)
+        return TriggerIntegrationUpdateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -29723,18 +30215,14 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationTwilioCreateRequest:
+class TriggerIntegrationCreateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
-    account_sid: Optional[str]
-    """The Twilio account SID"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
-    allow_from: Optional[str]
-    """Newline-or-comma-separated list of allowed senders. Use E.164 phone numbers with or
-    without the leading `+`. Set to `*` to allow all. Leave empty to deny all.
-    """
-    auth_token: Optional[str]
-    """The Twilio auth token"""
+    authenticate: Optional[bool]
+    """When enabled the integration requires authentication"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -29742,9 +30230,6 @@ class IntegrationTwilioCreateRequest:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     description: Optional[str]
     """The associated description"""
 
@@ -29754,80 +30239,79 @@ class IntegrationTwilioCreateRequest:
     name: Optional[str]
     """The associated name"""
 
+    schedule: Optional[str]
+    """The schedule for the trigger integration (interval, cron expression, or ISO date)"""
+
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    voice: Optional[str]
-    """The voice configuration structured string"""
+    timezone: Optional[str]
+    """An optional IANA timezone identifier used when evaluating the trigger schedule."""
 
-    def __init__(self, account_sid: Optional[str], allow_from: Optional[str], auth_token: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], voice: Optional[str]) -> None:
-        self.account_sid = account_sid
-        self.allow_from = allow_from
-        self.auth_token = auth_token
+    def __init__(self, alias: Optional[str], authenticate: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], schedule: Optional[str], session_duration: Optional[float], timezone: Optional[str]) -> None:
+        self.alias = alias
+        self.authenticate = authenticate
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.contact_collection = contact_collection
         self.description = description
         self.meta = meta
         self.name = name
+        self.schedule = schedule
         self.session_duration = session_duration
-        self.voice = voice
+        self.timezone = timezone
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioCreateRequest':
+    def from_dict(obj: Any) -> 'TriggerIntegrationCreateRequest':
         assert isinstance(obj, dict)
-        account_sid = from_union([from_str, from_none], obj.get("accountSid"))
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        auth_token = from_union([from_str, from_none], obj.get("authToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        authenticate = from_union([from_bool, from_none], obj.get("authenticate"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
+        schedule = from_union([from_str, from_none], obj.get("schedule"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        voice = from_union([from_str, from_none], obj.get("voice"))
-        return IntegrationTwilioCreateRequest(account_sid, allow_from, auth_token, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration, voice)
+        timezone = from_union([from_str, from_none], obj.get("timezone"))
+        return TriggerIntegrationCreateRequest(alias, authenticate, blueprint_id, bot_id, description, meta, name, schedule, session_duration, timezone)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.account_sid is not None:
-            result["accountSid"] = from_union([from_str, from_none], self.account_sid)
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.auth_token is not None:
-            result["authToken"] = from_union([from_str, from_none], self.auth_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.authenticate is not None:
+            result["authenticate"] = from_union([from_bool, from_none], self.authenticate)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.schedule is not None:
+            result["schedule"] = from_union([from_str, from_none], self.schedule)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.voice is not None:
-            result["voice"] = from_union([from_str, from_none], self.voice)
+        if self.timezone is not None:
+            result["timezone"] = from_union([from_str, from_none], self.timezone)
         return result
 
 
-class IntegrationTwilioCreateResponse:
+class TriggerIntegrationCreateResponse:
     id: str
-    """The ID of the Twilio Integration"""
+    """The ID of the Trigger Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioCreateResponse':
+    def from_dict(obj: Any) -> 'TriggerIntegrationCreateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationTwilioCreateResponse(id)
+        return TriggerIntegrationCreateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -29835,40 +30319,40 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationTwilioListParamsOrder(Enum):
+class TriggerIntegrationListParamsOrder(Enum):
     """The order of the paginated items"""
 
     ASC = "asc"
     DESC = "desc"
 
 
-class IntegrationTwilioListParams:
+class TriggerIntegrationListParams:
     cursor: Optional[str]
     """The cursor to use for pagination"""
 
     meta: Optional[Dict[str, str]]
     """Key-value pairs to filter the partner users by metadata"""
 
-    order: Optional[IntegrationTwilioListParamsOrder]
+    order: Optional[TriggerIntegrationListParamsOrder]
     """The order of the paginated items"""
 
     take: Optional[int]
     """The number of items to retrieve"""
 
-    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[IntegrationTwilioListParamsOrder], take: Optional[int]) -> None:
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[TriggerIntegrationListParamsOrder], take: Optional[int]) -> None:
         self.cursor = cursor
         self.meta = meta
         self.order = order
         self.take = take
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioListParams':
+    def from_dict(obj: Any) -> 'TriggerIntegrationListParams':
         assert isinstance(obj, dict)
         cursor = from_union([from_str, from_none], obj.get("cursor"))
         meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
-        order = from_union([IntegrationTwilioListParamsOrder, from_none], obj.get("order"))
+        order = from_union([TriggerIntegrationListParamsOrder, from_none], obj.get("order"))
         take = from_union([from_int, from_none], obj.get("take"))
-        return IntegrationTwilioListParams(cursor, meta, order, take)
+        return TriggerIntegrationListParams(cursor, meta, order, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -29877,20 +30361,20 @@ def to_dict(self) -> dict:
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
         if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(IntegrationTwilioListParamsOrder, x), from_none], self.order)
+            result["order"] = from_union([lambda x: to_enum(TriggerIntegrationListParamsOrder, x), from_none], self.order)
         if self.take is not None:
             result["take"] = from_union([from_int, from_none], self.take)
         return result
 
 
-class IntegrationTwilioListResponseItem:
-    """Blueprint properties"""
+class TriggerIntegrationListResponseItem:
+    """A bot configuration that can be applied without a dedicated bot instance."""
 
-    account_sid: Optional[str]
-    """The Twilio account SID"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
-    allow_from: Optional[str]
-    """Newline-or-comma-separated list of allowed senders"""
+    authenticate: Optional[bool]
+    """When enabled the integration requires authentication"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -29898,9 +30382,6 @@ class IntegrationTwilioListResponseItem:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
@@ -29910,114 +30391,137 @@ class IntegrationTwilioListResponseItem:
     id: str
     """The instance ID"""
 
+    last_trigger_at: Optional[float]
+    """The timestamp (ms) of the last trigger execution"""
+
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
+    next_trigger_at: Optional[float]
+    """The timestamp (ms) of the next scheduled trigger execution"""
+
+    schedule: Optional[str]
+    """The schedule for the trigger integration (interval, cron expression, ISO date, or null)"""
+
+    secret: str
+    """The Trigger integration secret"""
+
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
+    timezone: Optional[str]
+    """The IANA timezone identifier used to evaluate the trigger schedule."""
+
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    voice: Optional[str]
-    """The voice configuration structured string"""
-
-    def __init__(self, account_sid: Optional[str], allow_from: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, voice: Optional[str]) -> None:
-        self.account_sid = account_sid
-        self.allow_from = allow_from
+    def __init__(self, alias: Optional[str], authenticate: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: Optional[str], id: str, last_trigger_at: Optional[float], meta: Optional[Dict[str, Any]], name: Optional[str], next_trigger_at: Optional[float], schedule: Optional[str], secret: str, session_duration: Optional[float], timezone: Optional[str], updated_at: float) -> None:
+        self.alias = alias
+        self.authenticate = authenticate
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
         self.id = id
+        self.last_trigger_at = last_trigger_at
         self.meta = meta
         self.name = name
+        self.next_trigger_at = next_trigger_at
+        self.schedule = schedule
+        self.secret = secret
         self.session_duration = session_duration
+        self.timezone = timezone
         self.updated_at = updated_at
-        self.voice = voice
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioListResponseItem':
+    def from_dict(obj: Any) -> 'TriggerIntegrationListResponseItem':
         assert isinstance(obj, dict)
-        account_sid = from_union([from_str, from_none], obj.get("accountSid"))
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        authenticate = from_union([from_bool, from_none], obj.get("authenticate"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
+        last_trigger_at = from_union([from_float, from_none], obj.get("lastTriggerAt"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
+        next_trigger_at = from_union([from_float, from_none], obj.get("nextTriggerAt"))
+        schedule = from_union([from_str, from_none], obj.get("schedule"))
+        secret = from_str(obj.get("secret"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        timezone = from_union([from_str, from_none], obj.get("timezone"))
         updated_at = from_float(obj.get("updatedAt"))
-        voice = from_union([from_str, from_none], obj.get("voice"))
-        return IntegrationTwilioListResponseItem(account_sid, allow_from, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, voice)
+        return TriggerIntegrationListResponseItem(alias, authenticate, blueprint_id, bot_id, created_at, description, id, last_trigger_at, meta, name, next_trigger_at, schedule, secret, session_duration, timezone, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.account_sid is not None:
-            result["accountSid"] = from_union([from_str, from_none], self.account_sid)
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.authenticate is not None:
+            result["authenticate"] = from_union([from_bool, from_none], self.authenticate)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         result["id"] = from_str(self.id)
+        if self.last_trigger_at is not None:
+            result["lastTriggerAt"] = from_union([to_float, from_none], self.last_trigger_at)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.next_trigger_at is not None:
+            result["nextTriggerAt"] = from_union([to_float, from_none], self.next_trigger_at)
+        if self.schedule is not None:
+            result["schedule"] = from_union([from_str, from_none], self.schedule)
+        result["secret"] = from_str(self.secret)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.timezone is not None:
+            result["timezone"] = from_union([from_str, from_none], self.timezone)
         result["updatedAt"] = to_float(self.updated_at)
-        if self.voice is not None:
-            result["voice"] = from_union([from_str, from_none], self.voice)
         return result
 
 
-class IntegrationTwilioListResponse:
+class TriggerIntegrationListResponse:
     cursor: str
     """Cursor for fetching the next page"""
 
-    items: List[IntegrationTwilioListResponseItem]
+    items: List[TriggerIntegrationListResponseItem]
 
-    def __init__(self, cursor: str, items: List[IntegrationTwilioListResponseItem]) -> None:
+    def __init__(self, cursor: str, items: List[TriggerIntegrationListResponseItem]) -> None:
         self.cursor = cursor
         self.items = items
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioListResponse':
+    def from_dict(obj: Any) -> 'TriggerIntegrationListResponse':
         assert isinstance(obj, dict)
         cursor = from_str(obj.get("cursor"))
-        items = from_list(IntegrationTwilioListResponseItem.from_dict, obj.get("items"))
-        return IntegrationTwilioListResponse(cursor, items)
+        items = from_list(TriggerIntegrationListResponseItem.from_dict, obj.get("items"))
+        return TriggerIntegrationListResponse(cursor, items)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["cursor"] = from_str(self.cursor)
-        result["items"] = from_list(lambda x: to_class(IntegrationTwilioListResponseItem, x), self.items)
+        result["items"] = from_list(lambda x: to_class(TriggerIntegrationListResponseItem, x), self.items)
         return result
 
 
-class IntegrationTwilioListStreamItemData:
-    """Blueprint properties"""
+class TriggerIntegrationListStreamItemData:
+    """A bot configuration that can be applied without a dedicated bot instance."""
 
-    account_sid: Optional[str]
-    """The Twilio account SID"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
-    allow_from: Optional[str]
-    """Newline-or-comma-separated list of allowed senders"""
+    authenticate: Optional[bool]
+    """When enabled the integration requires authentication"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -30025,9 +30529,6 @@ class IntegrationTwilioListStreamItemData:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
-    contact_collection: Optional[bool]
-    """Weather to collect contacts"""
-
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
@@ -30037,144 +30538,167 @@ class IntegrationTwilioListStreamItemData:
     id: str
     """The instance ID"""
 
+    last_trigger_at: Optional[float]
+    """The timestamp (ms) of the last trigger execution"""
+
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
+    next_trigger_at: Optional[float]
+    """The timestamp (ms) of the next scheduled trigger execution"""
+
+    schedule: Optional[str]
+    """The schedule for the trigger integration (interval, cron expression, ISO date, or null)"""
+
+    secret: str
+    """The Trigger integration secret"""
+
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
+    timezone: Optional[str]
+    """The IANA timezone identifier used to evaluate the trigger schedule."""
+
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    voice: Optional[str]
-    """The voice configuration structured string"""
-
-    def __init__(self, account_sid: Optional[str], allow_from: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, voice: Optional[str]) -> None:
-        self.account_sid = account_sid
-        self.allow_from = allow_from
+    def __init__(self, alias: Optional[str], authenticate: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: Optional[str], id: str, last_trigger_at: Optional[float], meta: Optional[Dict[str, Any]], name: Optional[str], next_trigger_at: Optional[float], schedule: Optional[str], secret: str, session_duration: Optional[float], timezone: Optional[str], updated_at: float) -> None:
+        self.alias = alias
+        self.authenticate = authenticate
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
         self.id = id
+        self.last_trigger_at = last_trigger_at
         self.meta = meta
         self.name = name
+        self.next_trigger_at = next_trigger_at
+        self.schedule = schedule
+        self.secret = secret
         self.session_duration = session_duration
+        self.timezone = timezone
         self.updated_at = updated_at
-        self.voice = voice
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioListStreamItemData':
+    def from_dict(obj: Any) -> 'TriggerIntegrationListStreamItemData':
         assert isinstance(obj, dict)
-        account_sid = from_union([from_str, from_none], obj.get("accountSid"))
-        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        authenticate = from_union([from_bool, from_none], obj.get("authenticate"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
-        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
+        last_trigger_at = from_union([from_float, from_none], obj.get("lastTriggerAt"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
+        next_trigger_at = from_union([from_float, from_none], obj.get("nextTriggerAt"))
+        schedule = from_union([from_str, from_none], obj.get("schedule"))
+        secret = from_str(obj.get("secret"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        timezone = from_union([from_str, from_none], obj.get("timezone"))
         updated_at = from_float(obj.get("updatedAt"))
-        voice = from_union([from_str, from_none], obj.get("voice"))
-        return IntegrationTwilioListStreamItemData(account_sid, allow_from, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, voice)
+        return TriggerIntegrationListStreamItemData(alias, authenticate, blueprint_id, bot_id, created_at, description, id, last_trigger_at, meta, name, next_trigger_at, schedule, secret, session_duration, timezone, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.account_sid is not None:
-            result["accountSid"] = from_union([from_str, from_none], self.account_sid)
-        if self.allow_from is not None:
-            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.authenticate is not None:
+            result["authenticate"] = from_union([from_bool, from_none], self.authenticate)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.contact_collection is not None:
-            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         result["id"] = from_str(self.id)
+        if self.last_trigger_at is not None:
+            result["lastTriggerAt"] = from_union([to_float, from_none], self.last_trigger_at)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.next_trigger_at is not None:
+            result["nextTriggerAt"] = from_union([to_float, from_none], self.next_trigger_at)
+        if self.schedule is not None:
+            result["schedule"] = from_union([from_str, from_none], self.schedule)
+        result["secret"] = from_str(self.secret)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.timezone is not None:
+            result["timezone"] = from_union([from_str, from_none], self.timezone)
         result["updatedAt"] = to_float(self.updated_at)
-        if self.voice is not None:
-            result["voice"] = from_union([from_str, from_none], self.voice)
         return result
 
 
-class IntegrationTwilioListStreamItemType(Enum):
+class TriggerIntegrationListStreamItemType(Enum):
     """The type of event"""
 
     ITEM = "item"
 
 
-class IntegrationTwilioListStreamItem:
-    data: IntegrationTwilioListStreamItemData
-    """Blueprint properties"""
+class TriggerIntegrationListStreamItem:
+    data: TriggerIntegrationListStreamItemData
+    """A bot configuration that can be applied without a dedicated bot instance."""
 
-    type: IntegrationTwilioListStreamItemType
+    type: TriggerIntegrationListStreamItemType
     """The type of event"""
 
-    def __init__(self, data: IntegrationTwilioListStreamItemData, type: IntegrationTwilioListStreamItemType) -> None:
+    def __init__(self, data: TriggerIntegrationListStreamItemData, type: TriggerIntegrationListStreamItemType) -> None:
         self.data = data
         self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationTwilioListStreamItem':
+    def from_dict(obj: Any) -> 'TriggerIntegrationListStreamItem':
         assert isinstance(obj, dict)
-        data = IntegrationTwilioListStreamItemData.from_dict(obj.get("data"))
-        type = IntegrationTwilioListStreamItemType(obj.get("type"))
-        return IntegrationTwilioListStreamItem(data, type)
+        data = TriggerIntegrationListStreamItemData.from_dict(obj.get("data"))
+        type = TriggerIntegrationListStreamItemType(obj.get("type"))
+        return TriggerIntegrationListStreamItem(data, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["data"] = to_class(IntegrationTwilioListStreamItemData, self.data)
-        result["type"] = to_enum(IntegrationTwilioListStreamItemType, self.type)
+        result["data"] = to_class(TriggerIntegrationListStreamItemData, self.data)
+        result["type"] = to_enum(TriggerIntegrationListStreamItemType, self.type)
         return result
 
 
-class IntegrationWhatsAppDeleteParams:
-    whatsapp_integration_id: str
-    """The ID of the WhatsApp integration"""
+class IntegrationTwilioDeleteParams:
+    twilio_integration_id: str
+    """The ID of the Twilio integration"""
 
-    def __init__(self, whatsapp_integration_id: str) -> None:
-        self.whatsapp_integration_id = whatsapp_integration_id
+    def __init__(self, twilio_integration_id: str) -> None:
+        self.twilio_integration_id = twilio_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppDeleteParams':
+    def from_dict(obj: Any) -> 'IntegrationTwilioDeleteParams':
         assert isinstance(obj, dict)
-        whatsapp_integration_id = from_str(obj.get("whatsappIntegrationId"))
-        return IntegrationWhatsAppDeleteParams(whatsapp_integration_id)
+        twilio_integration_id = from_str(obj.get("twilioIntegrationId"))
+        return IntegrationTwilioDeleteParams(twilio_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["whatsappIntegrationId"] = from_str(self.whatsapp_integration_id)
+        result["twilioIntegrationId"] = from_str(self.twilio_integration_id)
         return result
 
 
-class IntegrationWhatsAppDeleteResponse:
+class IntegrationTwilioDeleteResponse:
     id: str
-    """The ID of the deleted WhatsApp integration"""
+    """The ID of the deleted Twilio integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppDeleteResponse':
+    def from_dict(obj: Any) -> 'IntegrationTwilioDeleteResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationWhatsAppDeleteResponse(id)
+        return IntegrationTwilioDeleteResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -30182,38 +30706,37 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationWhatsAppFetchParams:
-    whatsapp_integration_id: str
-    """The ID of the WhatsApp integration to retrieve"""
+class IntegrationTwilioFetchParams:
+    twilio_integration_id: str
+    """The ID of the Twilio integration to retrieve"""
 
-    def __init__(self, whatsapp_integration_id: str) -> None:
-        self.whatsapp_integration_id = whatsapp_integration_id
+    def __init__(self, twilio_integration_id: str) -> None:
+        self.twilio_integration_id = twilio_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppFetchParams':
+    def from_dict(obj: Any) -> 'IntegrationTwilioFetchParams':
         assert isinstance(obj, dict)
-        whatsapp_integration_id = from_str(obj.get("whatsappIntegrationId"))
-        return IntegrationWhatsAppFetchParams(whatsapp_integration_id)
+        twilio_integration_id = from_str(obj.get("twilioIntegrationId"))
+        return IntegrationTwilioFetchParams(twilio_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["whatsappIntegrationId"] = from_str(self.whatsapp_integration_id)
+        result["twilioIntegrationId"] = from_str(self.twilio_integration_id)
         return result
 
 
-class IntegrationWhatsAppFetchResponse:
+class IntegrationTwilioFetchResponse:
     """Blueprint properties"""
 
-    access_token: Optional[str]
-    """The WhatsApp integration access token (returned as '********' if configured, null
-    otherwise)
-    """
+    account_sid: Optional[str]
+    """The Twilio account SID"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
     """Newline-or-comma-separated list of allowed senders"""
 
-    attachments: Optional[bool]
-    """Weather the bot supports attachments"""
-
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -30238,22 +30761,19 @@ class IntegrationWhatsAppFetchResponse:
     name: Optional[str]
     """The associated name"""
 
-    phone_number_id: Optional[str]
-    """The WhatsApp integration phone number ID"""
-
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    verify_token: str
-    """The WhatsApp integration verify token"""
+    voice: Optional[str]
+    """The voice configuration structured string"""
 
-    def __init__(self, access_token: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], phone_number_id: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
-        self.access_token = access_token
+    def __init__(self, account_sid: Optional[str], alias: Optional[str], allow_from: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, voice: Optional[str]) -> None:
+        self.account_sid = account_sid
+        self.alias = alias
         self.allow_from = allow_from
-        self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
         self.contact_collection = contact_collection
@@ -30262,17 +30782,16 @@ def __init__(self, access_token: Optional[str], allow_from: Optional[str], attac
         self.id = id
         self.meta = meta
         self.name = name
-        self.phone_number_id = phone_number_id
         self.session_duration = session_duration
         self.updated_at = updated_at
-        self.verify_token = verify_token
+        self.voice = voice
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppFetchResponse':
+    def from_dict(obj: Any) -> 'IntegrationTwilioFetchResponse':
         assert isinstance(obj, dict)
-        access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        account_sid = from_union([from_str, from_none], obj.get("accountSid"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
         contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
@@ -30281,20 +30800,19 @@ def from_dict(obj: Any) -> 'IntegrationWhatsAppFetchResponse':
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        phone_number_id = from_union([from_str, from_none], obj.get("phoneNumberId"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        verify_token = from_str(obj.get("verifyToken"))
-        return IntegrationWhatsAppFetchResponse(access_token, allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, phone_number_id, session_duration, updated_at, verify_token)
+        voice = from_union([from_str, from_none], obj.get("voice"))
+        return IntegrationTwilioFetchResponse(account_sid, alias, allow_from, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, voice)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.access_token is not None:
-            result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.account_sid is not None:
+            result["accountSid"] = from_union([from_str, from_none], self.account_sid)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.attachments is not None:
-            result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
@@ -30309,46 +30827,45 @@ def to_dict(self) -> dict:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.phone_number_id is not None:
-            result["phoneNumberId"] = from_union([from_str, from_none], self.phone_number_id)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
         result["updatedAt"] = to_float(self.updated_at)
-        result["verifyToken"] = from_str(self.verify_token)
+        if self.voice is not None:
+            result["voice"] = from_union([from_str, from_none], self.voice)
         return result
 
 
-class IntegrationWhatsAppSetupParams:
-    whatsapp_integration_id: str
-    """The ID of the WhatsApp integration"""
+class IntegrationTwilioSetupParams:
+    twilio_integration_id: str
+    """The ID of the Twilio integration"""
 
-    def __init__(self, whatsapp_integration_id: str) -> None:
-        self.whatsapp_integration_id = whatsapp_integration_id
+    def __init__(self, twilio_integration_id: str) -> None:
+        self.twilio_integration_id = twilio_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppSetupParams':
+    def from_dict(obj: Any) -> 'IntegrationTwilioSetupParams':
         assert isinstance(obj, dict)
-        whatsapp_integration_id = from_str(obj.get("whatsappIntegrationId"))
-        return IntegrationWhatsAppSetupParams(whatsapp_integration_id)
+        twilio_integration_id = from_str(obj.get("twilioIntegrationId"))
+        return IntegrationTwilioSetupParams(twilio_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["whatsappIntegrationId"] = from_str(self.whatsapp_integration_id)
+        result["twilioIntegrationId"] = from_str(self.twilio_integration_id)
         return result
 
 
-class IntegrationWhatsAppSetupResponse:
+class IntegrationTwilioSetupResponse:
     id: str
-    """The ID of the WhatsApp Integration"""
+    """The ID of the Twilio Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppSetupResponse':
+    def from_dict(obj: Any) -> 'IntegrationTwilioSetupResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationWhatsAppSetupResponse(id)
+        return IntegrationTwilioSetupResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -30356,37 +30873,40 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationWhatsAppUpdateParams:
-    whatsapp_integration_id: str
-    """The ID of the WhatsApp integration"""
+class IntegrationTwilioUpdateParams:
+    twilio_integration_id: str
+    """The ID of the Twilio integration"""
 
-    def __init__(self, whatsapp_integration_id: str) -> None:
-        self.whatsapp_integration_id = whatsapp_integration_id
+    def __init__(self, twilio_integration_id: str) -> None:
+        self.twilio_integration_id = twilio_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppUpdateParams':
+    def from_dict(obj: Any) -> 'IntegrationTwilioUpdateParams':
         assert isinstance(obj, dict)
-        whatsapp_integration_id = from_str(obj.get("whatsappIntegrationId"))
-        return IntegrationWhatsAppUpdateParams(whatsapp_integration_id)
+        twilio_integration_id = from_str(obj.get("twilioIntegrationId"))
+        return IntegrationTwilioUpdateParams(twilio_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["whatsappIntegrationId"] = from_str(self.whatsapp_integration_id)
+        result["twilioIntegrationId"] = from_str(self.twilio_integration_id)
         return result
 
 
-class IntegrationWhatsAppUpdateRequest:
+class IntegrationTwilioUpdateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
-    access_token: Optional[str]
-    """The WhatsApp integration access token"""
+    account_sid: Optional[str]
+    """The Twilio account SID"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
     allow_from: Optional[str]
     """Newline-or-comma-separated list of allowed senders. Use E.164 phone numbers with or
     without the leading `+`. Set to `*` to allow all. Leave empty to deny all.
     """
-    attachments: Optional[bool]
-    """Weather the bot supports attachments"""
+    auth_token: Optional[str]
+    """The Twilio auth token"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -30406,49 +30926,53 @@ class IntegrationWhatsAppUpdateRequest:
     name: Optional[str]
     """The associated name"""
 
-    phone_number_id: Optional[str]
-    """The WhatsApp integration phone number ID"""
-
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    def __init__(self, access_token: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], phone_number_id: Optional[str], session_duration: Optional[float]) -> None:
-        self.access_token = access_token
+    voice: Optional[str]
+    """The voice configuration structured string"""
+
+    def __init__(self, account_sid: Optional[str], alias: Optional[str], allow_from: Optional[str], auth_token: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], voice: Optional[str]) -> None:
+        self.account_sid = account_sid
+        self.alias = alias
         self.allow_from = allow_from
-        self.attachments = attachments
+        self.auth_token = auth_token
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
         self.contact_collection = contact_collection
         self.description = description
         self.meta = meta
         self.name = name
-        self.phone_number_id = phone_number_id
         self.session_duration = session_duration
+        self.voice = voice
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppUpdateRequest':
+    def from_dict(obj: Any) -> 'IntegrationTwilioUpdateRequest':
         assert isinstance(obj, dict)
-        access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        account_sid = from_union([from_str, from_none], obj.get("accountSid"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        attachments = from_union([from_bool, from_none], obj.get("attachments"))
+        auth_token = from_union([from_str, from_none], obj.get("authToken"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
         contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        phone_number_id = from_union([from_str, from_none], obj.get("phoneNumberId"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return IntegrationWhatsAppUpdateRequest(access_token, allow_from, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, phone_number_id, session_duration)
+        voice = from_union([from_str, from_none], obj.get("voice"))
+        return IntegrationTwilioUpdateRequest(account_sid, alias, allow_from, auth_token, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration, voice)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.access_token is not None:
-            result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.account_sid is not None:
+            result["accountSid"] = from_union([from_str, from_none], self.account_sid)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.attachments is not None:
-            result["attachments"] = from_union([from_bool, from_none], self.attachments)
+        if self.auth_token is not None:
+            result["authToken"] = from_union([from_str, from_none], self.auth_token)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
@@ -30461,25 +30985,25 @@ def to_dict(self) -> dict:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.phone_number_id is not None:
-            result["phoneNumberId"] = from_union([from_str, from_none], self.phone_number_id)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.voice is not None:
+            result["voice"] = from_union([from_str, from_none], self.voice)
         return result
 
 
-class IntegrationWhatsAppUpdateResponse:
+class IntegrationTwilioUpdateResponse:
     id: str
-    """The ID of the WhatsApp Integration"""
+    """The ID of the Twilio Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppUpdateResponse':
+    def from_dict(obj: Any) -> 'IntegrationTwilioUpdateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationWhatsAppUpdateResponse(id)
+        return IntegrationTwilioUpdateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -30487,18 +31011,21 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationWhatsAppCreateRequest:
+class IntegrationTwilioCreateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
-    access_token: Optional[str]
-    """The WhatsApp integration access token"""
+    account_sid: Optional[str]
+    """The Twilio account SID"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
     allow_from: Optional[str]
     """Newline-or-comma-separated list of allowed senders. Use E.164 phone numbers with or
     without the leading `+`. Set to `*` to allow all. Leave empty to deny all.
     """
-    attachments: Optional[bool]
-    """Weather the bot supports attachments"""
+    auth_token: Optional[str]
+    """The Twilio auth token"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -30518,49 +31045,53 @@ class IntegrationWhatsAppCreateRequest:
     name: Optional[str]
     """The associated name"""
 
-    phone_number_id: Optional[str]
-    """The WhatsApp integration phone number ID"""
-
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
-    def __init__(self, access_token: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], phone_number_id: Optional[str], session_duration: Optional[float]) -> None:
-        self.access_token = access_token
+    voice: Optional[str]
+    """The voice configuration structured string"""
+
+    def __init__(self, account_sid: Optional[str], alias: Optional[str], allow_from: Optional[str], auth_token: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], voice: Optional[str]) -> None:
+        self.account_sid = account_sid
+        self.alias = alias
         self.allow_from = allow_from
-        self.attachments = attachments
+        self.auth_token = auth_token
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
         self.contact_collection = contact_collection
         self.description = description
         self.meta = meta
         self.name = name
-        self.phone_number_id = phone_number_id
         self.session_duration = session_duration
+        self.voice = voice
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppCreateRequest':
+    def from_dict(obj: Any) -> 'IntegrationTwilioCreateRequest':
         assert isinstance(obj, dict)
-        access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        account_sid = from_union([from_str, from_none], obj.get("accountSid"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        attachments = from_union([from_bool, from_none], obj.get("attachments"))
+        auth_token = from_union([from_str, from_none], obj.get("authToken"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
         contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        phone_number_id = from_union([from_str, from_none], obj.get("phoneNumberId"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        return IntegrationWhatsAppCreateRequest(access_token, allow_from, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, phone_number_id, session_duration)
+        voice = from_union([from_str, from_none], obj.get("voice"))
+        return IntegrationTwilioCreateRequest(account_sid, alias, allow_from, auth_token, blueprint_id, bot_id, contact_collection, description, meta, name, session_duration, voice)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.access_token is not None:
-            result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.account_sid is not None:
+            result["accountSid"] = from_union([from_str, from_none], self.account_sid)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.attachments is not None:
-            result["attachments"] = from_union([from_bool, from_none], self.attachments)
+        if self.auth_token is not None:
+            result["authToken"] = from_union([from_str, from_none], self.auth_token)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
@@ -30573,25 +31104,25 @@ def to_dict(self) -> dict:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.phone_number_id is not None:
-            result["phoneNumberId"] = from_union([from_str, from_none], self.phone_number_id)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.voice is not None:
+            result["voice"] = from_union([from_str, from_none], self.voice)
         return result
 
 
-class IntegrationWhatsAppCreateResponse:
+class IntegrationTwilioCreateResponse:
     id: str
-    """The ID of the WhatsApp Integration"""
+    """The ID of the Twilio Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppCreateResponse':
+    def from_dict(obj: Any) -> 'IntegrationTwilioCreateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationWhatsAppCreateResponse(id)
+        return IntegrationTwilioCreateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -30599,40 +31130,40 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationWhatsAppListParamsOrder(Enum):
+class IntegrationTwilioListParamsOrder(Enum):
     """The order of the paginated items"""
 
     ASC = "asc"
     DESC = "desc"
 
 
-class IntegrationWhatsAppListParams:
+class IntegrationTwilioListParams:
     cursor: Optional[str]
     """The cursor to use for pagination"""
 
     meta: Optional[Dict[str, str]]
     """Key-value pairs to filter the partner users by metadata"""
 
-    order: Optional[IntegrationWhatsAppListParamsOrder]
+    order: Optional[IntegrationTwilioListParamsOrder]
     """The order of the paginated items"""
 
     take: Optional[int]
     """The number of items to retrieve"""
 
-    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[IntegrationWhatsAppListParamsOrder], take: Optional[int]) -> None:
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[IntegrationTwilioListParamsOrder], take: Optional[int]) -> None:
         self.cursor = cursor
         self.meta = meta
         self.order = order
         self.take = take
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppListParams':
+    def from_dict(obj: Any) -> 'IntegrationTwilioListParams':
         assert isinstance(obj, dict)
         cursor = from_union([from_str, from_none], obj.get("cursor"))
         meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
-        order = from_union([IntegrationWhatsAppListParamsOrder, from_none], obj.get("order"))
+        order = from_union([IntegrationTwilioListParamsOrder, from_none], obj.get("order"))
         take = from_union([from_int, from_none], obj.get("take"))
-        return IntegrationWhatsAppListParams(cursor, meta, order, take)
+        return IntegrationTwilioListParams(cursor, meta, order, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -30641,25 +31172,23 @@ def to_dict(self) -> dict:
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
         if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(IntegrationWhatsAppListParamsOrder, x), from_none], self.order)
+            result["order"] = from_union([lambda x: to_enum(IntegrationTwilioListParamsOrder, x), from_none], self.order)
         if self.take is not None:
             result["take"] = from_union([from_int, from_none], self.take)
         return result
 
 
-class IntegrationWhatsAppListResponseItem:
+class IntegrationTwilioListResponseItem:
     """Blueprint properties"""
 
-    access_token: Optional[str]
-    """The WhatsApp integration access token (returned as '********' if configured, null
-    otherwise)
-    """
+    account_sid: Optional[str]
+    """The Twilio account SID"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
-    """Newline-or-comma-separated list of allowed senders. Use phone numbers in E.164 format
-    (digits only). Leave empty to block all. Use * to allow everyone.
-    """
-    attachments: Optional[bool]
-    """Weather the bot supports attachments"""
+    """Newline-or-comma-separated list of allowed senders"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -30685,22 +31214,19 @@ class IntegrationWhatsAppListResponseItem:
     name: Optional[str]
     """The associated name"""
 
-    phone_number_id: Optional[str]
-    """The WhatsApp integration phone number ID"""
-
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    verify_token: str
-    """The WhatsApp integration verify token"""
+    voice: Optional[str]
+    """The voice configuration structured string"""
 
-    def __init__(self, access_token: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], phone_number_id: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
-        self.access_token = access_token
+    def __init__(self, account_sid: Optional[str], alias: Optional[str], allow_from: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, voice: Optional[str]) -> None:
+        self.account_sid = account_sid
+        self.alias = alias
         self.allow_from = allow_from
-        self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
         self.contact_collection = contact_collection
@@ -30709,17 +31235,16 @@ def __init__(self, access_token: Optional[str], allow_from: Optional[str], attac
         self.id = id
         self.meta = meta
         self.name = name
-        self.phone_number_id = phone_number_id
         self.session_duration = session_duration
         self.updated_at = updated_at
-        self.verify_token = verify_token
+        self.voice = voice
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppListResponseItem':
+    def from_dict(obj: Any) -> 'IntegrationTwilioListResponseItem':
         assert isinstance(obj, dict)
-        access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        account_sid = from_union([from_str, from_none], obj.get("accountSid"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
         contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
@@ -30728,20 +31253,19 @@ def from_dict(obj: Any) -> 'IntegrationWhatsAppListResponseItem':
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        phone_number_id = from_union([from_str, from_none], obj.get("phoneNumberId"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        verify_token = from_str(obj.get("verifyToken"))
-        return IntegrationWhatsAppListResponseItem(access_token, allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, phone_number_id, session_duration, updated_at, verify_token)
+        voice = from_union([from_str, from_none], obj.get("voice"))
+        return IntegrationTwilioListResponseItem(account_sid, alias, allow_from, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, voice)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.access_token is not None:
-            result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.account_sid is not None:
+            result["accountSid"] = from_union([from_str, from_none], self.account_sid)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.attachments is not None:
-            result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
@@ -30756,52 +31280,49 @@ def to_dict(self) -> dict:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.phone_number_id is not None:
-            result["phoneNumberId"] = from_union([from_str, from_none], self.phone_number_id)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
         result["updatedAt"] = to_float(self.updated_at)
-        result["verifyToken"] = from_str(self.verify_token)
+        if self.voice is not None:
+            result["voice"] = from_union([from_str, from_none], self.voice)
         return result
 
 
-class IntegrationWhatsAppListResponse:
+class IntegrationTwilioListResponse:
     cursor: str
     """Cursor for fetching the next page"""
 
-    items: List[IntegrationWhatsAppListResponseItem]
+    items: List[IntegrationTwilioListResponseItem]
 
-    def __init__(self, cursor: str, items: List[IntegrationWhatsAppListResponseItem]) -> None:
+    def __init__(self, cursor: str, items: List[IntegrationTwilioListResponseItem]) -> None:
         self.cursor = cursor
         self.items = items
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppListResponse':
+    def from_dict(obj: Any) -> 'IntegrationTwilioListResponse':
         assert isinstance(obj, dict)
         cursor = from_str(obj.get("cursor"))
-        items = from_list(IntegrationWhatsAppListResponseItem.from_dict, obj.get("items"))
-        return IntegrationWhatsAppListResponse(cursor, items)
+        items = from_list(IntegrationTwilioListResponseItem.from_dict, obj.get("items"))
+        return IntegrationTwilioListResponse(cursor, items)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["cursor"] = from_str(self.cursor)
-        result["items"] = from_list(lambda x: to_class(IntegrationWhatsAppListResponseItem, x), self.items)
+        result["items"] = from_list(lambda x: to_class(IntegrationTwilioListResponseItem, x), self.items)
         return result
 
 
-class IntegrationWhatsAppListStreamItemData:
+class IntegrationTwilioListStreamItemData:
     """Blueprint properties"""
 
-    access_token: Optional[str]
-    """The WhatsApp integration access token (returned as '********' if configured, null
-    otherwise)
-    """
+    account_sid: Optional[str]
+    """The Twilio account SID"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     allow_from: Optional[str]
-    """Newline-or-comma-separated list of allowed senders. Use phone numbers in E.164 format
-    (digits only). Leave empty to block all. Use * to allow everyone.
-    """
-    attachments: Optional[bool]
-    """Weather the bot supports attachments"""
+    """Newline-or-comma-separated list of allowed senders"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -30827,22 +31348,19 @@ class IntegrationWhatsAppListStreamItemData:
     name: Optional[str]
     """The associated name"""
 
-    phone_number_id: Optional[str]
-    """The WhatsApp integration phone number ID"""
-
     session_duration: Optional[float]
     """The session duration (in milliseconds)"""
 
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    verify_token: str
-    """The WhatsApp integration verify token"""
+    voice: Optional[str]
+    """The voice configuration structured string"""
 
-    def __init__(self, access_token: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], phone_number_id: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
-        self.access_token = access_token
+    def __init__(self, account_sid: Optional[str], alias: Optional[str], allow_from: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], session_duration: Optional[float], updated_at: float, voice: Optional[str]) -> None:
+        self.account_sid = account_sid
+        self.alias = alias
         self.allow_from = allow_from
-        self.attachments = attachments
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
         self.contact_collection = contact_collection
@@ -30851,17 +31369,16 @@ def __init__(self, access_token: Optional[str], allow_from: Optional[str], attac
         self.id = id
         self.meta = meta
         self.name = name
-        self.phone_number_id = phone_number_id
         self.session_duration = session_duration
         self.updated_at = updated_at
-        self.verify_token = verify_token
+        self.voice = voice
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppListStreamItemData':
+    def from_dict(obj: Any) -> 'IntegrationTwilioListStreamItemData':
         assert isinstance(obj, dict)
-        access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        account_sid = from_union([from_str, from_none], obj.get("accountSid"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
-        attachments = from_union([from_bool, from_none], obj.get("attachments"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
         contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
@@ -30870,20 +31387,19 @@ def from_dict(obj: Any) -> 'IntegrationWhatsAppListStreamItemData':
         id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        phone_number_id = from_union([from_str, from_none], obj.get("phoneNumberId"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
         updated_at = from_float(obj.get("updatedAt"))
-        verify_token = from_str(obj.get("verifyToken"))
-        return IntegrationWhatsAppListStreamItemData(access_token, allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, phone_number_id, session_duration, updated_at, verify_token)
+        voice = from_union([from_str, from_none], obj.get("voice"))
+        return IntegrationTwilioListStreamItemData(account_sid, alias, allow_from, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, session_duration, updated_at, voice)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.access_token is not None:
-            result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.account_sid is not None:
+            result["accountSid"] = from_union([from_str, from_none], self.account_sid)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.allow_from is not None:
             result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
-        if self.attachments is not None:
-            result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
@@ -30898,77 +31414,76 @@ def to_dict(self) -> dict:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.phone_number_id is not None:
-            result["phoneNumberId"] = from_union([from_str, from_none], self.phone_number_id)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
         result["updatedAt"] = to_float(self.updated_at)
-        result["verifyToken"] = from_str(self.verify_token)
+        if self.voice is not None:
+            result["voice"] = from_union([from_str, from_none], self.voice)
         return result
 
 
-class IntegrationWhatsAppListStreamItemType(Enum):
+class IntegrationTwilioListStreamItemType(Enum):
     """The type of event"""
 
     ITEM = "item"
 
 
-class IntegrationWhatsAppListStreamItem:
-    data: IntegrationWhatsAppListStreamItemData
+class IntegrationTwilioListStreamItem:
+    data: IntegrationTwilioListStreamItemData
     """Blueprint properties"""
 
-    type: IntegrationWhatsAppListStreamItemType
+    type: IntegrationTwilioListStreamItemType
     """The type of event"""
 
-    def __init__(self, data: IntegrationWhatsAppListStreamItemData, type: IntegrationWhatsAppListStreamItemType) -> None:
+    def __init__(self, data: IntegrationTwilioListStreamItemData, type: IntegrationTwilioListStreamItemType) -> None:
         self.data = data
         self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWhatsAppListStreamItem':
+    def from_dict(obj: Any) -> 'IntegrationTwilioListStreamItem':
         assert isinstance(obj, dict)
-        data = IntegrationWhatsAppListStreamItemData.from_dict(obj.get("data"))
-        type = IntegrationWhatsAppListStreamItemType(obj.get("type"))
-        return IntegrationWhatsAppListStreamItem(data, type)
+        data = IntegrationTwilioListStreamItemData.from_dict(obj.get("data"))
+        type = IntegrationTwilioListStreamItemType(obj.get("type"))
+        return IntegrationTwilioListStreamItem(data, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["data"] = to_class(IntegrationWhatsAppListStreamItemData, self.data)
-        result["type"] = to_enum(IntegrationWhatsAppListStreamItemType, self.type)
+        result["data"] = to_class(IntegrationTwilioListStreamItemData, self.data)
+        result["type"] = to_enum(IntegrationTwilioListStreamItemType, self.type)
         return result
 
 
-class IntegrationWidgetCloneParams:
-    widget_integration_id: str
-    """The ID of the Widget integration"""
+class IntegrationWhatsAppDeleteParams:
+    whatsapp_integration_id: str
+    """The ID of the WhatsApp integration"""
 
-    def __init__(self, widget_integration_id: str) -> None:
-        self.widget_integration_id = widget_integration_id
+    def __init__(self, whatsapp_integration_id: str) -> None:
+        self.whatsapp_integration_id = whatsapp_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetCloneParams':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppDeleteParams':
         assert isinstance(obj, dict)
-        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
-        return IntegrationWidgetCloneParams(widget_integration_id)
+        whatsapp_integration_id = from_str(obj.get("whatsappIntegrationId"))
+        return IntegrationWhatsAppDeleteParams(whatsapp_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
+        result["whatsappIntegrationId"] = from_str(self.whatsapp_integration_id)
         return result
 
 
-class IntegrationWidgetCloneResponse:
+class IntegrationWhatsAppDeleteResponse:
     id: str
-    """The ID of the cloned Widget integration"""
+    """The ID of the deleted WhatsApp integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetCloneResponse':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppDeleteResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationWidgetCloneResponse(id)
+        return IntegrationWhatsAppDeleteResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -30976,71 +31491,40 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationWidgetDeleteParams:
-    widget_integration_id: str
-    """The ID of the Widget integration"""
-
-    def __init__(self, widget_integration_id: str) -> None:
-        self.widget_integration_id = widget_integration_id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetDeleteParams':
-        assert isinstance(obj, dict)
-        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
-        return IntegrationWidgetDeleteParams(widget_integration_id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
-        return result
-
-
-class IntegrationWidgetDeleteResponse:
-    id: str
-    """The ID of the deleted Widget integration"""
+class IntegrationWhatsAppFetchParams:
+    whatsapp_integration_id: str
+    """The ID of the WhatsApp integration to retrieve"""
 
-    def __init__(self, id: str) -> None:
-        self.id = id
+    def __init__(self, whatsapp_integration_id: str) -> None:
+        self.whatsapp_integration_id = whatsapp_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetDeleteResponse':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppFetchParams':
         assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
-        return IntegrationWidgetDeleteResponse(id)
+        whatsapp_integration_id = from_str(obj.get("whatsappIntegrationId"))
+        return IntegrationWhatsAppFetchParams(whatsapp_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["id"] = from_str(self.id)
+        result["whatsappIntegrationId"] = from_str(self.whatsapp_integration_id)
         return result
 
 
-class IntegrationWidgetFetchParams:
-    widget_integration_id: str
-    """The ID of the Widget integration to retrieve"""
-
-    def __init__(self, widget_integration_id: str) -> None:
-        self.widget_integration_id = widget_integration_id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetFetchParams':
-        assert isinstance(obj, dict)
-        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
-        return IntegrationWidgetFetchParams(widget_integration_id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
-        return result
+class IntegrationWhatsAppFetchResponse:
+    """Blueprint properties"""
 
+    access_token: Optional[str]
+    """The WhatsApp integration access token (returned as '********' if configured, null
+    otherwise)
+    """
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
-class IntegrationWidgetFetchResponse:
-    """A bot configuration that can be applied without a dedicated bot instance."""
+    allow_from: Optional[str]
+    """Newline-or-comma-separated list of allowed senders"""
 
     attachments: Optional[bool]
-    """Whether the Widget integration supports attachments"""
-
-    auto_scroll: Optional[bool]
-    """Whether the Widget integration auto scrolls"""
+    """Weather the bot supports attachments"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -31048,11 +31532,8 @@ class IntegrationWidgetFetchResponse:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
-    carousel: Optional[bool]
-    """Whether the Widget integration supports carousels"""
-
     contact_collection: Optional[bool]
-    """Whether the Widget integration collects contacts"""
+    """Weather to collect contacts"""
 
     created_at: float
     """The timestamp (ms) when the instance was created"""
@@ -31060,414 +31541,130 @@ class IntegrationWidgetFetchResponse:
     description: Optional[str]
     """The associated description"""
 
-    export_conversation: Optional[bool]
-    """Controls whether the Widget allows exporting the current conversation"""
-
-    form: Optional[bool]
-    """Whether the Widget integration supports forms"""
-
     id: str
     """The instance ID"""
 
-    initial: Optional[str]
-    """The initial message of the Widget integration"""
-
-    intro: Optional[str]
-    """The intro of the Widget integration"""
-
-    language: Optional[str]
-    """The language of the Widget integration"""
-
-    layout: Optional[str]
-    """The default layout of the Widget integration"""
-
-    math: Optional[bool]
-    """Whether the Widget integration supports math"""
-
-    maximize: Optional[bool]
-    """Controls whether the Widget allows maximizing the conversation"""
-
-    message_peek: Optional[bool]
-    """Controls whether the Widget allows peeking at the initial messages"""
-
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    origin: Optional[str]
-    """The origin URLs of the Widget integration"""
-
-    placeholder: Optional[str]
-    """The input placeholder of the Widget integration"""
-
-    plugins: Optional[str]
-    """The plugins of the Widget integration"""
-
-    powered_by: Optional[bool]
-    """Whether the Widget integration displays powered by"""
-
-    restart_conversation: Optional[bool]
-    """Controls whether the Widget allows restarting the conversation"""
+    phone_number_id: Optional[str]
+    """The WhatsApp integration phone number ID"""
 
     session_duration: Optional[float]
-    """The session duration of the Widget integration"""
-
-    start_first: Optional[bool]
-    """Whether the Widget integration starts first"""
-
-    stream: Optional[bool]
-    """Whether the Widget integration is streaming"""
-
-    theme: Optional[str]
-    """The theme of the Widget integration"""
-
-    title: Optional[str]
-    """The title of the Widget integration"""
-
-    tools: Optional[bool]
-    """Whether the Widget integration has tools"""
-
-    unfurl: Optional[bool]
-    """Whether the Widget integration unfurls links"""
+    """The session duration (in milliseconds)"""
 
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    verbose: Optional[bool]
-    """Whether the Widget integration is verbose"""
-
-    voice_in: Optional[bool]
-    """Whether the Widget integration supports voice input"""
-
-    voice_out: Optional[bool]
-    """Whether the Widget integration supports voice output"""
+    verify_token: str
+    """The WhatsApp integration verify token"""
 
-    def __init__(self, attachments: Optional[bool], auto_scroll: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], carousel: Optional[bool], contact_collection: Optional[bool], created_at: float, description: Optional[str], export_conversation: Optional[bool], form: Optional[bool], id: str, initial: Optional[str], intro: Optional[str], language: Optional[str], layout: Optional[str], math: Optional[bool], maximize: Optional[bool], message_peek: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], origin: Optional[str], placeholder: Optional[str], plugins: Optional[str], powered_by: Optional[bool], restart_conversation: Optional[bool], session_duration: Optional[float], start_first: Optional[bool], stream: Optional[bool], theme: Optional[str], title: Optional[str], tools: Optional[bool], unfurl: Optional[bool], updated_at: float, verbose: Optional[bool], voice_in: Optional[bool], voice_out: Optional[bool]) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], phone_number_id: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
+        self.access_token = access_token
+        self.alias = alias
+        self.allow_from = allow_from
         self.attachments = attachments
-        self.auto_scroll = auto_scroll
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.carousel = carousel
         self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
-        self.export_conversation = export_conversation
-        self.form = form
         self.id = id
-        self.initial = initial
-        self.intro = intro
-        self.language = language
-        self.layout = layout
-        self.math = math
-        self.maximize = maximize
-        self.message_peek = message_peek
         self.meta = meta
         self.name = name
-        self.origin = origin
-        self.placeholder = placeholder
-        self.plugins = plugins
-        self.powered_by = powered_by
-        self.restart_conversation = restart_conversation
+        self.phone_number_id = phone_number_id
         self.session_duration = session_duration
-        self.start_first = start_first
-        self.stream = stream
-        self.theme = theme
-        self.title = title
-        self.tools = tools
-        self.unfurl = unfurl
         self.updated_at = updated_at
-        self.verbose = verbose
-        self.voice_in = voice_in
-        self.voice_out = voice_out
+        self.verify_token = verify_token
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetFetchResponse':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppFetchResponse':
         assert isinstance(obj, dict)
+        access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
-        auto_scroll = from_union([from_bool, from_none], obj.get("autoScroll"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
-        carousel = from_union([from_bool, from_none], obj.get("carousel"))
         contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
-        export_conversation = from_union([from_bool, from_none], obj.get("exportConversation"))
-        form = from_union([from_bool, from_none], obj.get("form"))
         id = from_str(obj.get("id"))
-        initial = from_union([from_str, from_none], obj.get("initial"))
-        intro = from_union([from_str, from_none], obj.get("intro"))
-        language = from_union([from_str, from_none], obj.get("language"))
-        layout = from_union([from_str, from_none], obj.get("layout"))
-        math = from_union([from_bool, from_none], obj.get("math"))
-        maximize = from_union([from_bool, from_none], obj.get("maximize"))
-        message_peek = from_union([from_bool, from_none], obj.get("messagePeek"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        origin = from_union([from_str, from_none], obj.get("origin"))
-        placeholder = from_union([from_str, from_none], obj.get("placeholder"))
-        plugins = from_union([from_str, from_none], obj.get("plugins"))
-        powered_by = from_union([from_bool, from_none], obj.get("poweredBy"))
-        restart_conversation = from_union([from_bool, from_none], obj.get("restartConversation"))
+        phone_number_id = from_union([from_str, from_none], obj.get("phoneNumberId"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        start_first = from_union([from_bool, from_none], obj.get("startFirst"))
-        stream = from_union([from_bool, from_none], obj.get("stream"))
-        theme = from_union([from_str, from_none], obj.get("theme"))
-        title = from_union([from_str, from_none], obj.get("title"))
-        tools = from_union([from_bool, from_none], obj.get("tools"))
-        unfurl = from_union([from_bool, from_none], obj.get("unfurl"))
         updated_at = from_float(obj.get("updatedAt"))
-        verbose = from_union([from_bool, from_none], obj.get("verbose"))
-        voice_in = from_union([from_bool, from_none], obj.get("voiceIn"))
-        voice_out = from_union([from_bool, from_none], obj.get("voiceOut"))
-        return IntegrationWidgetFetchResponse(attachments, auto_scroll, blueprint_id, bot_id, carousel, contact_collection, created_at, description, export_conversation, form, id, initial, intro, language, layout, math, maximize, message_peek, meta, name, origin, placeholder, plugins, powered_by, restart_conversation, session_duration, start_first, stream, theme, title, tools, unfurl, updated_at, verbose, voice_in, voice_out)
+        verify_token = from_str(obj.get("verifyToken"))
+        return IntegrationWhatsAppFetchResponse(access_token, alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, phone_number_id, session_duration, updated_at, verify_token)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.access_token is not None:
+            result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
-        if self.auto_scroll is not None:
-            result["autoScroll"] = from_union([from_bool, from_none], self.auto_scroll)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.carousel is not None:
-            result["carousel"] = from_union([from_bool, from_none], self.carousel)
         if self.contact_collection is not None:
             result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
-        if self.export_conversation is not None:
-            result["exportConversation"] = from_union([from_bool, from_none], self.export_conversation)
-        if self.form is not None:
-            result["form"] = from_union([from_bool, from_none], self.form)
         result["id"] = from_str(self.id)
-        if self.initial is not None:
-            result["initial"] = from_union([from_str, from_none], self.initial)
-        if self.intro is not None:
-            result["intro"] = from_union([from_str, from_none], self.intro)
-        if self.language is not None:
-            result["language"] = from_union([from_str, from_none], self.language)
-        if self.layout is not None:
-            result["layout"] = from_union([from_str, from_none], self.layout)
-        if self.math is not None:
-            result["math"] = from_union([from_bool, from_none], self.math)
-        if self.maximize is not None:
-            result["maximize"] = from_union([from_bool, from_none], self.maximize)
-        if self.message_peek is not None:
-            result["messagePeek"] = from_union([from_bool, from_none], self.message_peek)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.origin is not None:
-            result["origin"] = from_union([from_str, from_none], self.origin)
-        if self.placeholder is not None:
-            result["placeholder"] = from_union([from_str, from_none], self.placeholder)
-        if self.plugins is not None:
-            result["plugins"] = from_union([from_str, from_none], self.plugins)
-        if self.powered_by is not None:
-            result["poweredBy"] = from_union([from_bool, from_none], self.powered_by)
-        if self.restart_conversation is not None:
-            result["restartConversation"] = from_union([from_bool, from_none], self.restart_conversation)
+        if self.phone_number_id is not None:
+            result["phoneNumberId"] = from_union([from_str, from_none], self.phone_number_id)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.start_first is not None:
-            result["startFirst"] = from_union([from_bool, from_none], self.start_first)
-        if self.stream is not None:
-            result["stream"] = from_union([from_bool, from_none], self.stream)
-        if self.theme is not None:
-            result["theme"] = from_union([from_str, from_none], self.theme)
-        if self.title is not None:
-            result["title"] = from_union([from_str, from_none], self.title)
-        if self.tools is not None:
-            result["tools"] = from_union([from_bool, from_none], self.tools)
-        if self.unfurl is not None:
-            result["unfurl"] = from_union([from_bool, from_none], self.unfurl)
         result["updatedAt"] = to_float(self.updated_at)
-        if self.verbose is not None:
-            result["verbose"] = from_union([from_bool, from_none], self.verbose)
-        if self.voice_in is not None:
-            result["voiceIn"] = from_union([from_bool, from_none], self.voice_in)
-        if self.voice_out is not None:
-            result["voiceOut"] = from_union([from_bool, from_none], self.voice_out)
-        return result
-
-
-class WidgetIntegrationFileAttachParams:
-    file_id: str
-    """The ID of the file to attach"""
-
-    widget_integration_id: str
-    """The ID of the widget integration"""
-
-    def __init__(self, file_id: str, widget_integration_id: str) -> None:
-        self.file_id = file_id
-        self.widget_integration_id = widget_integration_id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'WidgetIntegrationFileAttachParams':
-        assert isinstance(obj, dict)
-        file_id = from_str(obj.get("fileId"))
-        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
-        return WidgetIntegrationFileAttachParams(file_id, widget_integration_id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["fileId"] = from_str(self.file_id)
-        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
-        return result
-
-
-class WidgetIntegrationFileAttachRequestType(Enum):
-    """The attachment slot type for the file"""
-
-    BAR = "bar"
-    BOT = "bot"
-    BUTTON = "button"
-    USER = "user"
-
-
-class WidgetIntegrationFileAttachRequest:
-    type: WidgetIntegrationFileAttachRequestType
-    """The attachment slot type for the file"""
-
-    def __init__(self, type: WidgetIntegrationFileAttachRequestType) -> None:
-        self.type = type
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'WidgetIntegrationFileAttachRequest':
-        assert isinstance(obj, dict)
-        type = WidgetIntegrationFileAttachRequestType(obj.get("type"))
-        return WidgetIntegrationFileAttachRequest(type)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["type"] = to_enum(WidgetIntegrationFileAttachRequestType, self.type)
-        return result
-
-
-class WidgetIntegrationFileAttachResponse:
-    id: str
-    """The ID of the attached file"""
-
-    type: str
-    """The attachment slot type"""
-
-    widget_integration_id: str
-    """The ID of the widget integration"""
-
-    def __init__(self, id: str, type: str, widget_integration_id: str) -> None:
-        self.id = id
-        self.type = type
-        self.widget_integration_id = widget_integration_id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'WidgetIntegrationFileAttachResponse':
-        assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
-        type = from_str(obj.get("type"))
-        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
-        return WidgetIntegrationFileAttachResponse(id, type, widget_integration_id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["id"] = from_str(self.id)
-        result["type"] = from_str(self.type)
-        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
-        return result
-
-
-class WidgetIntegrationFileDetachParams:
-    file_id: str
-    """The ID of the file to detach"""
-
-    widget_integration_id: str
-    """The ID of the widget integration"""
-
-    def __init__(self, file_id: str, widget_integration_id: str) -> None:
-        self.file_id = file_id
-        self.widget_integration_id = widget_integration_id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'WidgetIntegrationFileDetachParams':
-        assert isinstance(obj, dict)
-        file_id = from_str(obj.get("fileId"))
-        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
-        return WidgetIntegrationFileDetachParams(file_id, widget_integration_id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["fileId"] = from_str(self.file_id)
-        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
-        return result
-
-
-class WidgetIntegrationFileDetachResponse:
-    id: str
-    """The ID of the detached file"""
-
-    type: str
-    """The attachment slot type that was cleared"""
-
-    widget_integration_id: str
-    """The ID of the widget integration"""
-
-    def __init__(self, id: str, type: str, widget_integration_id: str) -> None:
-        self.id = id
-        self.type = type
-        self.widget_integration_id = widget_integration_id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'WidgetIntegrationFileDetachResponse':
-        assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
-        type = from_str(obj.get("type"))
-        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
-        return WidgetIntegrationFileDetachResponse(id, type, widget_integration_id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["id"] = from_str(self.id)
-        result["type"] = from_str(self.type)
-        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
+        result["verifyToken"] = from_str(self.verify_token)
         return result
 
 
-class IntegrationWidgetSetupParams:
-    widget_integration_id: str
-    """The ID of the Widget integration"""
+class IntegrationWhatsAppSetupParams:
+    whatsapp_integration_id: str
+    """The ID of the WhatsApp integration"""
 
-    def __init__(self, widget_integration_id: str) -> None:
-        self.widget_integration_id = widget_integration_id
+    def __init__(self, whatsapp_integration_id: str) -> None:
+        self.whatsapp_integration_id = whatsapp_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetSetupParams':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppSetupParams':
         assert isinstance(obj, dict)
-        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
-        return IntegrationWidgetSetupParams(widget_integration_id)
+        whatsapp_integration_id = from_str(obj.get("whatsappIntegrationId"))
+        return IntegrationWhatsAppSetupParams(whatsapp_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
+        result["whatsappIntegrationId"] = from_str(self.whatsapp_integration_id)
         return result
 
 
-class IntegrationWidgetSetupResponse:
+class IntegrationWhatsAppSetupResponse:
     id: str
-    """The ID of the Widget integration"""
+    """The ID of the WhatsApp Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetSetupResponse':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppSetupResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationWidgetSetupResponse(id)
+        return IntegrationWhatsAppSetupResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -31475,33 +31672,40 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationWidgetUpdateParams:
-    widget_integration_id: str
-    """The ID of the Widget integration"""
+class IntegrationWhatsAppUpdateParams:
+    whatsapp_integration_id: str
+    """The ID of the WhatsApp integration"""
 
-    def __init__(self, widget_integration_id: str) -> None:
-        self.widget_integration_id = widget_integration_id
+    def __init__(self, whatsapp_integration_id: str) -> None:
+        self.whatsapp_integration_id = whatsapp_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetUpdateParams':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppUpdateParams':
         assert isinstance(obj, dict)
-        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
-        return IntegrationWidgetUpdateParams(widget_integration_id)
+        whatsapp_integration_id = from_str(obj.get("whatsappIntegrationId"))
+        return IntegrationWhatsAppUpdateParams(whatsapp_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
+        result["whatsappIntegrationId"] = from_str(self.whatsapp_integration_id)
         return result
 
 
-class IntegrationWidgetUpdateRequest:
+class IntegrationWhatsAppUpdateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
-    attachments: Optional[bool]
-    """Whether the Widget integration supports attachments"""
+    access_token: Optional[str]
+    """The WhatsApp integration access token"""
 
-    auto_scroll: Optional[bool]
-    """Whether the Widget integration auto scrolls"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    allow_from: Optional[str]
+    """Newline-or-comma-separated list of allowed senders. Use E.164 phone numbers with or
+    without the leading `+`. Set to `*` to allow all. Leave empty to deny all.
+    """
+    attachments: Optional[bool]
+    """Weather the bot supports attachments"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -31509,249 +31713,96 @@ class IntegrationWidgetUpdateRequest:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
-    carousel: Optional[bool]
-    """Whether the Widget integration supports carousels"""
-
     contact_collection: Optional[bool]
-    """Whether the Widget integration collects contacts"""
+    """Weather to collect contacts"""
 
     description: Optional[str]
     """The associated description"""
 
-    export_conversation: Optional[bool]
-    """Controls whether the Widget allows exporting the current conversation"""
-
-    form: Optional[bool]
-    """Whether the Widget integration supports forms"""
-
-    initial: Optional[str]
-    """The initial message of the Widget integration"""
-
-    intro: Optional[str]
-    """The intro of the Widget integration"""
-
-    language: Optional[str]
-    """The language of the Widget integration"""
-
-    layout: Optional[str]
-    """The default layout of the Widget integration"""
-
-    math: Optional[bool]
-    """Whether the Widget integration supports math"""
-
-    maximize: Optional[bool]
-    """Controls whether the Widget allows maximizing the conversation"""
-
-    message_peek: Optional[bool]
-    """Controls whether the Widget allows peeking at the initial messages"""
-
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    origin: Optional[str]
-    """The origin URLs of the Widget integration"""
-
-    placeholder: Optional[str]
-    """The input placeholder of the Widget integration"""
-
-    plugins: Optional[str]
-    """The plugins of the Widget integration"""
-
-    powered_by: Optional[bool]
-    """Whether the Widget integration displays powered by"""
-
-    restart_conversation: Optional[bool]
-    """Controls whether the Widget allows restarting the conversation"""
+    phone_number_id: Optional[str]
+    """The WhatsApp integration phone number ID"""
 
     session_duration: Optional[float]
-    """The session duration of the Widget integration"""
-
-    start_first: Optional[bool]
-    """Whether the Widget integration starts first"""
-
-    stream: Optional[bool]
-    """Whether the Widget integration is streaming"""
-
-    theme: Optional[str]
-    """The theme of the Widget integration"""
-
-    title: Optional[str]
-    """The title of the Widget integration"""
-
-    tools: Optional[bool]
-    """Whether the Widget integration has tools"""
-
-    unfurl: Optional[bool]
-    """Whether the Widget integration unfurls links"""
-
-    verbose: Optional[bool]
-    """Whether the Widget integration is verbose"""
-
-    voice_in: Optional[bool]
-    """Controls whether the Widget allows voice input"""
-
-    voice_out: Optional[bool]
-    """Controls whether the Widget allows voice output"""
+    """The session duration (in milliseconds)"""
 
-    def __init__(self, attachments: Optional[bool], auto_scroll: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], carousel: Optional[bool], contact_collection: Optional[bool], description: Optional[str], export_conversation: Optional[bool], form: Optional[bool], initial: Optional[str], intro: Optional[str], language: Optional[str], layout: Optional[str], math: Optional[bool], maximize: Optional[bool], message_peek: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], origin: Optional[str], placeholder: Optional[str], plugins: Optional[str], powered_by: Optional[bool], restart_conversation: Optional[bool], session_duration: Optional[float], start_first: Optional[bool], stream: Optional[bool], theme: Optional[str], title: Optional[str], tools: Optional[bool], unfurl: Optional[bool], verbose: Optional[bool], voice_in: Optional[bool], voice_out: Optional[bool]) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], phone_number_id: Optional[str], session_duration: Optional[float]) -> None:
+        self.access_token = access_token
+        self.alias = alias
+        self.allow_from = allow_from
         self.attachments = attachments
-        self.auto_scroll = auto_scroll
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.carousel = carousel
         self.contact_collection = contact_collection
         self.description = description
-        self.export_conversation = export_conversation
-        self.form = form
-        self.initial = initial
-        self.intro = intro
-        self.language = language
-        self.layout = layout
-        self.math = math
-        self.maximize = maximize
-        self.message_peek = message_peek
         self.meta = meta
         self.name = name
-        self.origin = origin
-        self.placeholder = placeholder
-        self.plugins = plugins
-        self.powered_by = powered_by
-        self.restart_conversation = restart_conversation
+        self.phone_number_id = phone_number_id
         self.session_duration = session_duration
-        self.start_first = start_first
-        self.stream = stream
-        self.theme = theme
-        self.title = title
-        self.tools = tools
-        self.unfurl = unfurl
-        self.verbose = verbose
-        self.voice_in = voice_in
-        self.voice_out = voice_out
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetUpdateRequest':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppUpdateRequest':
         assert isinstance(obj, dict)
+        access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
-        auto_scroll = from_union([from_bool, from_none], obj.get("autoScroll"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
-        carousel = from_union([from_bool, from_none], obj.get("carousel"))
         contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
-        export_conversation = from_union([from_bool, from_none], obj.get("exportConversation"))
-        form = from_union([from_bool, from_none], obj.get("form"))
-        initial = from_union([from_str, from_none], obj.get("initial"))
-        intro = from_union([from_str, from_none], obj.get("intro"))
-        language = from_union([from_str, from_none], obj.get("language"))
-        layout = from_union([from_str, from_none], obj.get("layout"))
-        math = from_union([from_bool, from_none], obj.get("math"))
-        maximize = from_union([from_bool, from_none], obj.get("maximize"))
-        message_peek = from_union([from_bool, from_none], obj.get("messagePeek"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        origin = from_union([from_str, from_none], obj.get("origin"))
-        placeholder = from_union([from_str, from_none], obj.get("placeholder"))
-        plugins = from_union([from_str, from_none], obj.get("plugins"))
-        powered_by = from_union([from_bool, from_none], obj.get("poweredBy"))
-        restart_conversation = from_union([from_bool, from_none], obj.get("restartConversation"))
+        phone_number_id = from_union([from_str, from_none], obj.get("phoneNumberId"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        start_first = from_union([from_bool, from_none], obj.get("startFirst"))
-        stream = from_union([from_bool, from_none], obj.get("stream"))
-        theme = from_union([from_str, from_none], obj.get("theme"))
-        title = from_union([from_str, from_none], obj.get("title"))
-        tools = from_union([from_bool, from_none], obj.get("tools"))
-        unfurl = from_union([from_bool, from_none], obj.get("unfurl"))
-        verbose = from_union([from_bool, from_none], obj.get("verbose"))
-        voice_in = from_union([from_bool, from_none], obj.get("voiceIn"))
-        voice_out = from_union([from_bool, from_none], obj.get("voiceOut"))
-        return IntegrationWidgetUpdateRequest(attachments, auto_scroll, blueprint_id, bot_id, carousel, contact_collection, description, export_conversation, form, initial, intro, language, layout, math, maximize, message_peek, meta, name, origin, placeholder, plugins, powered_by, restart_conversation, session_duration, start_first, stream, theme, title, tools, unfurl, verbose, voice_in, voice_out)
+        return IntegrationWhatsAppUpdateRequest(access_token, alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, phone_number_id, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.access_token is not None:
+            result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
-        if self.auto_scroll is not None:
-            result["autoScroll"] = from_union([from_bool, from_none], self.auto_scroll)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.carousel is not None:
-            result["carousel"] = from_union([from_bool, from_none], self.carousel)
         if self.contact_collection is not None:
             result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
-        if self.export_conversation is not None:
-            result["exportConversation"] = from_union([from_bool, from_none], self.export_conversation)
-        if self.form is not None:
-            result["form"] = from_union([from_bool, from_none], self.form)
-        if self.initial is not None:
-            result["initial"] = from_union([from_str, from_none], self.initial)
-        if self.intro is not None:
-            result["intro"] = from_union([from_str, from_none], self.intro)
-        if self.language is not None:
-            result["language"] = from_union([from_str, from_none], self.language)
-        if self.layout is not None:
-            result["layout"] = from_union([from_str, from_none], self.layout)
-        if self.math is not None:
-            result["math"] = from_union([from_bool, from_none], self.math)
-        if self.maximize is not None:
-            result["maximize"] = from_union([from_bool, from_none], self.maximize)
-        if self.message_peek is not None:
-            result["messagePeek"] = from_union([from_bool, from_none], self.message_peek)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.origin is not None:
-            result["origin"] = from_union([from_str, from_none], self.origin)
-        if self.placeholder is not None:
-            result["placeholder"] = from_union([from_str, from_none], self.placeholder)
-        if self.plugins is not None:
-            result["plugins"] = from_union([from_str, from_none], self.plugins)
-        if self.powered_by is not None:
-            result["poweredBy"] = from_union([from_bool, from_none], self.powered_by)
-        if self.restart_conversation is not None:
-            result["restartConversation"] = from_union([from_bool, from_none], self.restart_conversation)
+        if self.phone_number_id is not None:
+            result["phoneNumberId"] = from_union([from_str, from_none], self.phone_number_id)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.start_first is not None:
-            result["startFirst"] = from_union([from_bool, from_none], self.start_first)
-        if self.stream is not None:
-            result["stream"] = from_union([from_bool, from_none], self.stream)
-        if self.theme is not None:
-            result["theme"] = from_union([from_str, from_none], self.theme)
-        if self.title is not None:
-            result["title"] = from_union([from_str, from_none], self.title)
-        if self.tools is not None:
-            result["tools"] = from_union([from_bool, from_none], self.tools)
-        if self.unfurl is not None:
-            result["unfurl"] = from_union([from_bool, from_none], self.unfurl)
-        if self.verbose is not None:
-            result["verbose"] = from_union([from_bool, from_none], self.verbose)
-        if self.voice_in is not None:
-            result["voiceIn"] = from_union([from_bool, from_none], self.voice_in)
-        if self.voice_out is not None:
-            result["voiceOut"] = from_union([from_bool, from_none], self.voice_out)
         return result
 
 
-class IntegrationWidgetUpdateResponse:
+class IntegrationWhatsAppUpdateResponse:
     id: str
-    """The ID of the Widget Integration"""
+    """The ID of the WhatsApp Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetUpdateResponse':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppUpdateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationWidgetUpdateResponse(id)
+        return IntegrationWhatsAppUpdateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -31759,14 +31810,21 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationWidgetCreateRequest:
+class IntegrationWhatsAppCreateRequest:
     """A bot configuration that can be applied without a dedicated bot instance."""
 
-    attachments: Optional[bool]
-    """Weather the Widget integration supports attachments"""
+    access_token: Optional[str]
+    """The WhatsApp integration access token"""
 
-    auto_scroll: Optional[bool]
-    """Whether the Widget integration auto scrolls"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    allow_from: Optional[str]
+    """Newline-or-comma-separated list of allowed senders. Use E.164 phone numbers with or
+    without the leading `+`. Set to `*` to allow all. Leave empty to deny all.
+    """
+    attachments: Optional[bool]
+    """Weather the bot supports attachments"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -31774,249 +31832,96 @@ class IntegrationWidgetCreateRequest:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
-    carousel: Optional[bool]
-    """Weather the Widget integration supports carousels"""
-
     contact_collection: Optional[bool]
-    """Whether the Widget integration collects contacts"""
+    """Weather to collect contacts"""
 
     description: Optional[str]
     """The associated description"""
 
-    export_conversation: Optional[bool]
-    """Controls whether the Widget allows exporting the current conversation"""
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
 
-    form: Optional[bool]
-    """Weather the Widget integration supports forms"""
+    name: Optional[str]
+    """The associated name"""
 
-    initial: Optional[str]
-    """The initial message of the Widget integration"""
-
-    intro: Optional[str]
-    """The intro of the Widget integration"""
-
-    language: Optional[str]
-    """The language of the Widget integration"""
-
-    layout: Optional[str]
-    """The default layout of the Widget integration"""
-
-    math: Optional[bool]
-    """Weather the Widget integration supports math"""
-
-    maximize: Optional[bool]
-    """Controls whether the Widget allows maximizing the conversation"""
-
-    message_peek: Optional[bool]
-    """Controls whether the Widget allows peeking at the initial messages"""
-
-    meta: Optional[Dict[str, Any]]
-    """Meta data information"""
-
-    name: Optional[str]
-    """The associated name"""
-
-    origin: Optional[str]
-    """The origin URLs of the Widget integration"""
-
-    placeholder: Optional[str]
-    """The input placeholder of the Widget integration"""
-
-    plugins: Optional[str]
-    """The plugins of the Widget integration"""
-
-    powered_by: Optional[bool]
-    """Whether the Widget integration displays powered by"""
-
-    restart_conversation: Optional[bool]
-    """Controls whether the Widget allows restarting the conversation"""
+    phone_number_id: Optional[str]
+    """The WhatsApp integration phone number ID"""
 
     session_duration: Optional[float]
-    """The session duration of the Widget integration"""
-
-    start_first: Optional[bool]
-    """Whether the Widget integration starts first"""
-
-    stream: Optional[bool]
-    """Whether the Widget integration is streaming"""
-
-    theme: Optional[str]
-    """The theme of the Widget integration"""
-
-    title: Optional[str]
-    """The title of the Widget integration"""
-
-    tools: Optional[bool]
-    """Whether the Widget integration has tools"""
-
-    unfurl: Optional[bool]
-    """Whether the Widget integration unfurls links"""
-
-    verbose: Optional[bool]
-    """Whether the Widget integration is verbose"""
-
-    voice_in: Optional[bool]
-    """Controls whether the Widget allows voice input"""
-
-    voice_out: Optional[bool]
-    """Controls whether the Widget allows voice output"""
+    """The session duration (in milliseconds)"""
 
-    def __init__(self, attachments: Optional[bool], auto_scroll: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], carousel: Optional[bool], contact_collection: Optional[bool], description: Optional[str], export_conversation: Optional[bool], form: Optional[bool], initial: Optional[str], intro: Optional[str], language: Optional[str], layout: Optional[str], math: Optional[bool], maximize: Optional[bool], message_peek: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], origin: Optional[str], placeholder: Optional[str], plugins: Optional[str], powered_by: Optional[bool], restart_conversation: Optional[bool], session_duration: Optional[float], start_first: Optional[bool], stream: Optional[bool], theme: Optional[str], title: Optional[str], tools: Optional[bool], unfurl: Optional[bool], verbose: Optional[bool], voice_in: Optional[bool], voice_out: Optional[bool]) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], phone_number_id: Optional[str], session_duration: Optional[float]) -> None:
+        self.access_token = access_token
+        self.alias = alias
+        self.allow_from = allow_from
         self.attachments = attachments
-        self.auto_scroll = auto_scroll
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.carousel = carousel
         self.contact_collection = contact_collection
         self.description = description
-        self.export_conversation = export_conversation
-        self.form = form
-        self.initial = initial
-        self.intro = intro
-        self.language = language
-        self.layout = layout
-        self.math = math
-        self.maximize = maximize
-        self.message_peek = message_peek
         self.meta = meta
         self.name = name
-        self.origin = origin
-        self.placeholder = placeholder
-        self.plugins = plugins
-        self.powered_by = powered_by
-        self.restart_conversation = restart_conversation
+        self.phone_number_id = phone_number_id
         self.session_duration = session_duration
-        self.start_first = start_first
-        self.stream = stream
-        self.theme = theme
-        self.title = title
-        self.tools = tools
-        self.unfurl = unfurl
-        self.verbose = verbose
-        self.voice_in = voice_in
-        self.voice_out = voice_out
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetCreateRequest':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppCreateRequest':
         assert isinstance(obj, dict)
+        access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
-        auto_scroll = from_union([from_bool, from_none], obj.get("autoScroll"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
-        carousel = from_union([from_bool, from_none], obj.get("carousel"))
         contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         description = from_union([from_str, from_none], obj.get("description"))
-        export_conversation = from_union([from_bool, from_none], obj.get("exportConversation"))
-        form = from_union([from_bool, from_none], obj.get("form"))
-        initial = from_union([from_str, from_none], obj.get("initial"))
-        intro = from_union([from_str, from_none], obj.get("intro"))
-        language = from_union([from_str, from_none], obj.get("language"))
-        layout = from_union([from_str, from_none], obj.get("layout"))
-        math = from_union([from_bool, from_none], obj.get("math"))
-        maximize = from_union([from_bool, from_none], obj.get("maximize"))
-        message_peek = from_union([from_bool, from_none], obj.get("messagePeek"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        origin = from_union([from_str, from_none], obj.get("origin"))
-        placeholder = from_union([from_str, from_none], obj.get("placeholder"))
-        plugins = from_union([from_str, from_none], obj.get("plugins"))
-        powered_by = from_union([from_bool, from_none], obj.get("poweredBy"))
-        restart_conversation = from_union([from_bool, from_none], obj.get("restartConversation"))
+        phone_number_id = from_union([from_str, from_none], obj.get("phoneNumberId"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        start_first = from_union([from_bool, from_none], obj.get("startFirst"))
-        stream = from_union([from_bool, from_none], obj.get("stream"))
-        theme = from_union([from_str, from_none], obj.get("theme"))
-        title = from_union([from_str, from_none], obj.get("title"))
-        tools = from_union([from_bool, from_none], obj.get("tools"))
-        unfurl = from_union([from_bool, from_none], obj.get("unfurl"))
-        verbose = from_union([from_bool, from_none], obj.get("verbose"))
-        voice_in = from_union([from_bool, from_none], obj.get("voiceIn"))
-        voice_out = from_union([from_bool, from_none], obj.get("voiceOut"))
-        return IntegrationWidgetCreateRequest(attachments, auto_scroll, blueprint_id, bot_id, carousel, contact_collection, description, export_conversation, form, initial, intro, language, layout, math, maximize, message_peek, meta, name, origin, placeholder, plugins, powered_by, restart_conversation, session_duration, start_first, stream, theme, title, tools, unfurl, verbose, voice_in, voice_out)
+        return IntegrationWhatsAppCreateRequest(access_token, alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, description, meta, name, phone_number_id, session_duration)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.access_token is not None:
+            result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
-        if self.auto_scroll is not None:
-            result["autoScroll"] = from_union([from_bool, from_none], self.auto_scroll)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.carousel is not None:
-            result["carousel"] = from_union([from_bool, from_none], self.carousel)
         if self.contact_collection is not None:
             result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
-        if self.export_conversation is not None:
-            result["exportConversation"] = from_union([from_bool, from_none], self.export_conversation)
-        if self.form is not None:
-            result["form"] = from_union([from_bool, from_none], self.form)
-        if self.initial is not None:
-            result["initial"] = from_union([from_str, from_none], self.initial)
-        if self.intro is not None:
-            result["intro"] = from_union([from_str, from_none], self.intro)
-        if self.language is not None:
-            result["language"] = from_union([from_str, from_none], self.language)
-        if self.layout is not None:
-            result["layout"] = from_union([from_str, from_none], self.layout)
-        if self.math is not None:
-            result["math"] = from_union([from_bool, from_none], self.math)
-        if self.maximize is not None:
-            result["maximize"] = from_union([from_bool, from_none], self.maximize)
-        if self.message_peek is not None:
-            result["messagePeek"] = from_union([from_bool, from_none], self.message_peek)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.origin is not None:
-            result["origin"] = from_union([from_str, from_none], self.origin)
-        if self.placeholder is not None:
-            result["placeholder"] = from_union([from_str, from_none], self.placeholder)
-        if self.plugins is not None:
-            result["plugins"] = from_union([from_str, from_none], self.plugins)
-        if self.powered_by is not None:
-            result["poweredBy"] = from_union([from_bool, from_none], self.powered_by)
-        if self.restart_conversation is not None:
-            result["restartConversation"] = from_union([from_bool, from_none], self.restart_conversation)
+        if self.phone_number_id is not None:
+            result["phoneNumberId"] = from_union([from_str, from_none], self.phone_number_id)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.start_first is not None:
-            result["startFirst"] = from_union([from_bool, from_none], self.start_first)
-        if self.stream is not None:
-            result["stream"] = from_union([from_bool, from_none], self.stream)
-        if self.theme is not None:
-            result["theme"] = from_union([from_str, from_none], self.theme)
-        if self.title is not None:
-            result["title"] = from_union([from_str, from_none], self.title)
-        if self.tools is not None:
-            result["tools"] = from_union([from_bool, from_none], self.tools)
-        if self.unfurl is not None:
-            result["unfurl"] = from_union([from_bool, from_none], self.unfurl)
-        if self.verbose is not None:
-            result["verbose"] = from_union([from_bool, from_none], self.verbose)
-        if self.voice_in is not None:
-            result["voiceIn"] = from_union([from_bool, from_none], self.voice_in)
-        if self.voice_out is not None:
-            result["voiceOut"] = from_union([from_bool, from_none], self.voice_out)
         return result
 
 
-class IntegrationWidgetCreateResponse:
+class IntegrationWhatsAppCreateResponse:
     id: str
-    """The ID of the Widget Integration"""
+    """The ID of the WhatsApp Integration"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetCreateResponse':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppCreateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return IntegrationWidgetCreateResponse(id)
+        return IntegrationWhatsAppCreateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -32024,40 +31929,40 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationWidgetListParamsOrder(Enum):
+class IntegrationWhatsAppListParamsOrder(Enum):
     """The order of the paginated items"""
 
     ASC = "asc"
     DESC = "desc"
 
 
-class IntegrationWidgetListParams:
+class IntegrationWhatsAppListParams:
     cursor: Optional[str]
     """The cursor to use for pagination"""
 
     meta: Optional[Dict[str, str]]
     """Key-value pairs to filter the partner users by metadata"""
 
-    order: Optional[IntegrationWidgetListParamsOrder]
+    order: Optional[IntegrationWhatsAppListParamsOrder]
     """The order of the paginated items"""
 
     take: Optional[int]
     """The number of items to retrieve"""
 
-    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[IntegrationWidgetListParamsOrder], take: Optional[int]) -> None:
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[IntegrationWhatsAppListParamsOrder], take: Optional[int]) -> None:
         self.cursor = cursor
         self.meta = meta
         self.order = order
         self.take = take
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetListParams':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppListParams':
         assert isinstance(obj, dict)
         cursor = from_union([from_str, from_none], obj.get("cursor"))
         meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
-        order = from_union([IntegrationWidgetListParamsOrder, from_none], obj.get("order"))
+        order = from_union([IntegrationWhatsAppListParamsOrder, from_none], obj.get("order"))
         take = from_union([from_int, from_none], obj.get("take"))
-        return IntegrationWidgetListParams(cursor, meta, order, take)
+        return IntegrationWhatsAppListParams(cursor, meta, order, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -32066,20 +31971,28 @@ def to_dict(self) -> dict:
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
         if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(IntegrationWidgetListParamsOrder, x), from_none], self.order)
+            result["order"] = from_union([lambda x: to_enum(IntegrationWhatsAppListParamsOrder, x), from_none], self.order)
         if self.take is not None:
             result["take"] = from_union([from_int, from_none], self.take)
         return result
 
 
-class IntegrationWidgetListResponseItem:
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class IntegrationWhatsAppListResponseItem:
+    """Blueprint properties"""
 
-    attachments: Optional[bool]
-    """Weather the Widget integration supports attachments"""
+    access_token: Optional[str]
+    """The WhatsApp integration access token (returned as '********' if configured, null
+    otherwise)
+    """
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
-    auto_scroll: Optional[bool]
-    """Whether the Widget integration auto scrolls"""
+    allow_from: Optional[str]
+    """Newline-or-comma-separated list of allowed senders. Use phone numbers in E.164 format
+    (digits only). Leave empty to block all. Use * to allow everyone.
+    """
+    attachments: Optional[bool]
+    """Weather the bot supports attachments"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -32087,11 +32000,8 @@ class IntegrationWidgetListResponseItem:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
-    carousel: Optional[bool]
-    """Weather the Widget integration supports carousels"""
-
     contact_collection: Optional[bool]
-    """Whether the Widget integration collects contacts"""
+    """Weather to collect contacts"""
 
     created_at: float
     """The timestamp (ms) when the instance was created"""
@@ -32099,275 +32009,139 @@ class IntegrationWidgetListResponseItem:
     description: Optional[str]
     """The associated description"""
 
-    export_conversation: Optional[bool]
-    """Controls whether the Widget allows exporting the current conversation"""
-
-    form: Optional[bool]
-    """Weather the Widget integration supports forms"""
-
     id: str
     """The instance ID"""
 
-    initial: Optional[str]
-    """The initial message of the Widget integration"""
-
-    intro: Optional[str]
-    """The intro of the Widget integration"""
-
-    language: Optional[str]
-    """The language of the Widget integration"""
-
-    layout: Optional[str]
-    """The default layout of the Widget integration"""
-
-    math: Optional[bool]
-    """Weather the Widget integration supports math"""
-
-    maximize: Optional[bool]
-    """Controls whether the Widget allows maximizing the conversation"""
-
-    message_peek: Optional[bool]
-    """Controls whether the Widget allows peeking at the initial messages"""
-
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    origin: Optional[str]
-    """The origin URLs of the Widget integration"""
-
-    placeholder: Optional[str]
-    """The input placeholder of the Widget integration"""
-
-    plugins: Optional[str]
-    """The plugins of the Widget integration"""
-
-    powered_by: Optional[bool]
-    """Whether the Widget integration displays powered by"""
-
-    restart_conversation: Optional[bool]
-    """Controls whether the Widget allows restarting the conversation"""
+    phone_number_id: Optional[str]
+    """The WhatsApp integration phone number ID"""
 
     session_duration: Optional[float]
-    """The session duration of the Widget integration"""
-
-    start_first: Optional[bool]
-    """Whether the Widget integration starts first"""
-
-    stream: Optional[bool]
-    """Whether the Widget integration is streaming"""
-
-    theme: Optional[str]
-    """The theme of the Widget integration"""
-
-    title: Optional[str]
-    """The title of the Widget integration"""
-
-    tools: Optional[bool]
-    """Whether the Widget integration has tools"""
-
-    unfurl: Optional[bool]
-    """Whether the Widget integration unfurls links"""
+    """The session duration (in milliseconds)"""
 
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    verbose: Optional[bool]
-    """Whether the Widget integration is verbose"""
-
-    voice_in: Optional[bool]
-    """Whether the Widget integration supports voice input"""
-
-    voice_out: Optional[bool]
-    """Whether the Widget integration supports voice output"""
+    verify_token: str
+    """The WhatsApp integration verify token"""
 
-    def __init__(self, attachments: Optional[bool], auto_scroll: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], carousel: Optional[bool], contact_collection: Optional[bool], created_at: float, description: Optional[str], export_conversation: Optional[bool], form: Optional[bool], id: str, initial: Optional[str], intro: Optional[str], language: Optional[str], layout: Optional[str], math: Optional[bool], maximize: Optional[bool], message_peek: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], origin: Optional[str], placeholder: Optional[str], plugins: Optional[str], powered_by: Optional[bool], restart_conversation: Optional[bool], session_duration: Optional[float], start_first: Optional[bool], stream: Optional[bool], theme: Optional[str], title: Optional[str], tools: Optional[bool], unfurl: Optional[bool], updated_at: float, verbose: Optional[bool], voice_in: Optional[bool], voice_out: Optional[bool]) -> None:
+    def __init__(self, access_token: Optional[str], alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], phone_number_id: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
+        self.access_token = access_token
+        self.alias = alias
+        self.allow_from = allow_from
         self.attachments = attachments
-        self.auto_scroll = auto_scroll
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
-        self.carousel = carousel
         self.contact_collection = contact_collection
         self.created_at = created_at
         self.description = description
-        self.export_conversation = export_conversation
-        self.form = form
         self.id = id
-        self.initial = initial
-        self.intro = intro
-        self.language = language
-        self.layout = layout
-        self.math = math
-        self.maximize = maximize
-        self.message_peek = message_peek
         self.meta = meta
         self.name = name
-        self.origin = origin
-        self.placeholder = placeholder
-        self.plugins = plugins
-        self.powered_by = powered_by
-        self.restart_conversation = restart_conversation
+        self.phone_number_id = phone_number_id
         self.session_duration = session_duration
-        self.start_first = start_first
-        self.stream = stream
-        self.theme = theme
-        self.title = title
-        self.tools = tools
-        self.unfurl = unfurl
         self.updated_at = updated_at
-        self.verbose = verbose
-        self.voice_in = voice_in
-        self.voice_out = voice_out
+        self.verify_token = verify_token
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetListResponseItem':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppListResponseItem':
         assert isinstance(obj, dict)
+        access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
-        auto_scroll = from_union([from_bool, from_none], obj.get("autoScroll"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
-        carousel = from_union([from_bool, from_none], obj.get("carousel"))
         contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
-        export_conversation = from_union([from_bool, from_none], obj.get("exportConversation"))
-        form = from_union([from_bool, from_none], obj.get("form"))
         id = from_str(obj.get("id"))
-        initial = from_union([from_str, from_none], obj.get("initial"))
-        intro = from_union([from_str, from_none], obj.get("intro"))
-        language = from_union([from_str, from_none], obj.get("language"))
-        layout = from_union([from_str, from_none], obj.get("layout"))
-        math = from_union([from_bool, from_none], obj.get("math"))
-        maximize = from_union([from_bool, from_none], obj.get("maximize"))
-        message_peek = from_union([from_bool, from_none], obj.get("messagePeek"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        origin = from_union([from_str, from_none], obj.get("origin"))
-        placeholder = from_union([from_str, from_none], obj.get("placeholder"))
-        plugins = from_union([from_str, from_none], obj.get("plugins"))
-        powered_by = from_union([from_bool, from_none], obj.get("poweredBy"))
-        restart_conversation = from_union([from_bool, from_none], obj.get("restartConversation"))
+        phone_number_id = from_union([from_str, from_none], obj.get("phoneNumberId"))
         session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
-        start_first = from_union([from_bool, from_none], obj.get("startFirst"))
-        stream = from_union([from_bool, from_none], obj.get("stream"))
-        theme = from_union([from_str, from_none], obj.get("theme"))
-        title = from_union([from_str, from_none], obj.get("title"))
-        tools = from_union([from_bool, from_none], obj.get("tools"))
-        unfurl = from_union([from_bool, from_none], obj.get("unfurl"))
         updated_at = from_float(obj.get("updatedAt"))
-        verbose = from_union([from_bool, from_none], obj.get("verbose"))
-        voice_in = from_union([from_bool, from_none], obj.get("voiceIn"))
-        voice_out = from_union([from_bool, from_none], obj.get("voiceOut"))
-        return IntegrationWidgetListResponseItem(attachments, auto_scroll, blueprint_id, bot_id, carousel, contact_collection, created_at, description, export_conversation, form, id, initial, intro, language, layout, math, maximize, message_peek, meta, name, origin, placeholder, plugins, powered_by, restart_conversation, session_duration, start_first, stream, theme, title, tools, unfurl, updated_at, verbose, voice_in, voice_out)
+        verify_token = from_str(obj.get("verifyToken"))
+        return IntegrationWhatsAppListResponseItem(access_token, alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, phone_number_id, session_duration, updated_at, verify_token)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.access_token is not None:
+            result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
-        if self.auto_scroll is not None:
-            result["autoScroll"] = from_union([from_bool, from_none], self.auto_scroll)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.carousel is not None:
-            result["carousel"] = from_union([from_bool, from_none], self.carousel)
         if self.contact_collection is not None:
             result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
-        if self.export_conversation is not None:
-            result["exportConversation"] = from_union([from_bool, from_none], self.export_conversation)
-        if self.form is not None:
-            result["form"] = from_union([from_bool, from_none], self.form)
         result["id"] = from_str(self.id)
-        if self.initial is not None:
-            result["initial"] = from_union([from_str, from_none], self.initial)
-        if self.intro is not None:
-            result["intro"] = from_union([from_str, from_none], self.intro)
-        if self.language is not None:
-            result["language"] = from_union([from_str, from_none], self.language)
-        if self.layout is not None:
-            result["layout"] = from_union([from_str, from_none], self.layout)
-        if self.math is not None:
-            result["math"] = from_union([from_bool, from_none], self.math)
-        if self.maximize is not None:
-            result["maximize"] = from_union([from_bool, from_none], self.maximize)
-        if self.message_peek is not None:
-            result["messagePeek"] = from_union([from_bool, from_none], self.message_peek)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.origin is not None:
-            result["origin"] = from_union([from_str, from_none], self.origin)
-        if self.placeholder is not None:
-            result["placeholder"] = from_union([from_str, from_none], self.placeholder)
-        if self.plugins is not None:
-            result["plugins"] = from_union([from_str, from_none], self.plugins)
-        if self.powered_by is not None:
-            result["poweredBy"] = from_union([from_bool, from_none], self.powered_by)
-        if self.restart_conversation is not None:
-            result["restartConversation"] = from_union([from_bool, from_none], self.restart_conversation)
+        if self.phone_number_id is not None:
+            result["phoneNumberId"] = from_union([from_str, from_none], self.phone_number_id)
         if self.session_duration is not None:
             result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
-        if self.start_first is not None:
-            result["startFirst"] = from_union([from_bool, from_none], self.start_first)
-        if self.stream is not None:
-            result["stream"] = from_union([from_bool, from_none], self.stream)
-        if self.theme is not None:
-            result["theme"] = from_union([from_str, from_none], self.theme)
-        if self.title is not None:
-            result["title"] = from_union([from_str, from_none], self.title)
-        if self.tools is not None:
-            result["tools"] = from_union([from_bool, from_none], self.tools)
-        if self.unfurl is not None:
-            result["unfurl"] = from_union([from_bool, from_none], self.unfurl)
         result["updatedAt"] = to_float(self.updated_at)
-        if self.verbose is not None:
-            result["verbose"] = from_union([from_bool, from_none], self.verbose)
-        if self.voice_in is not None:
-            result["voiceIn"] = from_union([from_bool, from_none], self.voice_in)
-        if self.voice_out is not None:
-            result["voiceOut"] = from_union([from_bool, from_none], self.voice_out)
+        result["verifyToken"] = from_str(self.verify_token)
         return result
 
 
-class IntegrationWidgetListResponse:
+class IntegrationWhatsAppListResponse:
     cursor: str
     """Cursor for fetching the next page"""
 
-    items: List[IntegrationWidgetListResponseItem]
+    items: List[IntegrationWhatsAppListResponseItem]
 
-    def __init__(self, cursor: str, items: List[IntegrationWidgetListResponseItem]) -> None:
+    def __init__(self, cursor: str, items: List[IntegrationWhatsAppListResponseItem]) -> None:
         self.cursor = cursor
         self.items = items
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetListResponse':
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppListResponse':
         assert isinstance(obj, dict)
         cursor = from_str(obj.get("cursor"))
-        items = from_list(IntegrationWidgetListResponseItem.from_dict, obj.get("items"))
-        return IntegrationWidgetListResponse(cursor, items)
+        items = from_list(IntegrationWhatsAppListResponseItem.from_dict, obj.get("items"))
+        return IntegrationWhatsAppListResponse(cursor, items)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["cursor"] = from_str(self.cursor)
-        result["items"] = from_list(lambda x: to_class(IntegrationWidgetListResponseItem, x), self.items)
+        result["items"] = from_list(lambda x: to_class(IntegrationWhatsAppListResponseItem, x), self.items)
         return result
 
 
-class IntegrationWidgetListStreamItemData:
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class IntegrationWhatsAppListStreamItemData:
+    """Blueprint properties"""
 
-    attachments: Optional[bool]
-    """Weather the Widget integration supports attachments"""
+    access_token: Optional[str]
+    """The WhatsApp integration access token (returned as '********' if configured, null
+    otherwise)
+    """
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
-    auto_scroll: Optional[bool]
-    """Whether the Widget integration auto scrolls"""
+    allow_from: Optional[str]
+    """Newline-or-comma-separated list of allowed senders. Use phone numbers in E.164 format
+    (digits only). Leave empty to block all. Use * to allow everyone.
+    """
+    attachments: Optional[bool]
+    """Weather the bot supports attachments"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
@@ -32375,11 +32149,8 @@ class IntegrationWidgetListStreamItemData:
     bot_id: Optional[str]
     """The ID of the bot this configuration is using"""
 
-    carousel: Optional[bool]
-    """Weather the Widget integration supports carousels"""
-
     contact_collection: Optional[bool]
-    """Whether the Widget integration collects contacts"""
+    """Weather to collect contacts"""
 
     created_at: float
     """The timestamp (ms) when the instance was created"""
@@ -32387,52 +32158,301 @@ class IntegrationWidgetListStreamItemData:
     description: Optional[str]
     """The associated description"""
 
-    export_conversation: Optional[bool]
-    """Controls whether the Widget allows exporting the current conversation"""
-
-    form: Optional[bool]
-    """Weather the Widget integration supports forms"""
-
     id: str
     """The instance ID"""
 
-    initial: Optional[str]
-    """The initial message of the Widget integration"""
-
-    intro: Optional[str]
-    """The intro of the Widget integration"""
-
-    language: Optional[str]
-    """The language of the Widget integration"""
-
-    layout: Optional[str]
-    """The default layout of the Widget integration"""
-
-    math: Optional[bool]
-    """Weather the Widget integration supports math"""
-
-    maximize: Optional[bool]
-    """Controls whether the Widget allows maximizing the conversation"""
-
-    message_peek: Optional[bool]
-    """Controls whether the Widget allows peeking at the initial messages"""
-
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    origin: Optional[str]
-    """The origin URLs of the Widget integration"""
+    phone_number_id: Optional[str]
+    """The WhatsApp integration phone number ID"""
 
-    placeholder: Optional[str]
-    """The input placeholder of the Widget integration"""
+    session_duration: Optional[float]
+    """The session duration (in milliseconds)"""
 
-    plugins: Optional[str]
-    """The plugins of the Widget integration"""
+    updated_at: float
+    """The timestamp (ms) when the instance was updated"""
 
-    powered_by: Optional[bool]
+    verify_token: str
+    """The WhatsApp integration verify token"""
+
+    def __init__(self, access_token: Optional[str], alias: Optional[str], allow_from: Optional[str], attachments: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], contact_collection: Optional[bool], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], phone_number_id: Optional[str], session_duration: Optional[float], updated_at: float, verify_token: str) -> None:
+        self.access_token = access_token
+        self.alias = alias
+        self.allow_from = allow_from
+        self.attachments = attachments
+        self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
+        self.contact_collection = contact_collection
+        self.created_at = created_at
+        self.description = description
+        self.id = id
+        self.meta = meta
+        self.name = name
+        self.phone_number_id = phone_number_id
+        self.session_duration = session_duration
+        self.updated_at = updated_at
+        self.verify_token = verify_token
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppListStreamItemData':
+        assert isinstance(obj, dict)
+        access_token = from_union([from_str, from_none], obj.get("accessToken"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        allow_from = from_union([from_str, from_none], obj.get("allowFrom"))
+        attachments = from_union([from_bool, from_none], obj.get("attachments"))
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
+        created_at = from_float(obj.get("createdAt"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        id = from_str(obj.get("id"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        phone_number_id = from_union([from_str, from_none], obj.get("phoneNumberId"))
+        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        updated_at = from_float(obj.get("updatedAt"))
+        verify_token = from_str(obj.get("verifyToken"))
+        return IntegrationWhatsAppListStreamItemData(access_token, alias, allow_from, attachments, blueprint_id, bot_id, contact_collection, created_at, description, id, meta, name, phone_number_id, session_duration, updated_at, verify_token)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.access_token is not None:
+            result["accessToken"] = from_union([from_str, from_none], self.access_token)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.allow_from is not None:
+            result["allowFrom"] = from_union([from_str, from_none], self.allow_from)
+        if self.attachments is not None:
+            result["attachments"] = from_union([from_bool, from_none], self.attachments)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
+        result["createdAt"] = to_float(self.created_at)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        result["id"] = from_str(self.id)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.phone_number_id is not None:
+            result["phoneNumberId"] = from_union([from_str, from_none], self.phone_number_id)
+        if self.session_duration is not None:
+            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        result["updatedAt"] = to_float(self.updated_at)
+        result["verifyToken"] = from_str(self.verify_token)
+        return result
+
+
+class IntegrationWhatsAppListStreamItemType(Enum):
+    """The type of event"""
+
+    ITEM = "item"
+
+
+class IntegrationWhatsAppListStreamItem:
+    data: IntegrationWhatsAppListStreamItemData
+    """Blueprint properties"""
+
+    type: IntegrationWhatsAppListStreamItemType
+    """The type of event"""
+
+    def __init__(self, data: IntegrationWhatsAppListStreamItemData, type: IntegrationWhatsAppListStreamItemType) -> None:
+        self.data = data
+        self.type = type
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWhatsAppListStreamItem':
+        assert isinstance(obj, dict)
+        data = IntegrationWhatsAppListStreamItemData.from_dict(obj.get("data"))
+        type = IntegrationWhatsAppListStreamItemType(obj.get("type"))
+        return IntegrationWhatsAppListStreamItem(data, type)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["data"] = to_class(IntegrationWhatsAppListStreamItemData, self.data)
+        result["type"] = to_enum(IntegrationWhatsAppListStreamItemType, self.type)
+        return result
+
+
+class IntegrationWidgetCloneParams:
+    widget_integration_id: str
+    """The ID of the Widget integration"""
+
+    def __init__(self, widget_integration_id: str) -> None:
+        self.widget_integration_id = widget_integration_id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetCloneParams':
+        assert isinstance(obj, dict)
+        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
+        return IntegrationWidgetCloneParams(widget_integration_id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
+        return result
+
+
+class IntegrationWidgetCloneResponse:
+    id: str
+    """The ID of the cloned Widget integration"""
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetCloneResponse':
+        assert isinstance(obj, dict)
+        id = from_str(obj.get("id"))
+        return IntegrationWidgetCloneResponse(id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["id"] = from_str(self.id)
+        return result
+
+
+class IntegrationWidgetDeleteParams:
+    widget_integration_id: str
+    """The ID of the Widget integration"""
+
+    def __init__(self, widget_integration_id: str) -> None:
+        self.widget_integration_id = widget_integration_id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetDeleteParams':
+        assert isinstance(obj, dict)
+        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
+        return IntegrationWidgetDeleteParams(widget_integration_id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
+        return result
+
+
+class IntegrationWidgetDeleteResponse:
+    id: str
+    """The ID of the deleted Widget integration"""
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetDeleteResponse':
+        assert isinstance(obj, dict)
+        id = from_str(obj.get("id"))
+        return IntegrationWidgetDeleteResponse(id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["id"] = from_str(self.id)
+        return result
+
+
+class IntegrationWidgetFetchParams:
+    widget_integration_id: str
+    """The ID of the Widget integration to retrieve"""
+
+    def __init__(self, widget_integration_id: str) -> None:
+        self.widget_integration_id = widget_integration_id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetFetchParams':
+        assert isinstance(obj, dict)
+        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
+        return IntegrationWidgetFetchParams(widget_integration_id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
+        return result
+
+
+class IntegrationWidgetFetchResponse:
+    """A bot configuration that can be applied without a dedicated bot instance."""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    attachments: Optional[bool]
+    """Whether the Widget integration supports attachments"""
+
+    auto_scroll: Optional[bool]
+    """Whether the Widget integration auto scrolls"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    bot_id: Optional[str]
+    """The ID of the bot this configuration is using"""
+
+    carousel: Optional[bool]
+    """Whether the Widget integration supports carousels"""
+
+    contact_collection: Optional[bool]
+    """Whether the Widget integration collects contacts"""
+
+    created_at: float
+    """The timestamp (ms) when the instance was created"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    export_conversation: Optional[bool]
+    """Controls whether the Widget allows exporting the current conversation"""
+
+    form: Optional[bool]
+    """Whether the Widget integration supports forms"""
+
+    id: str
+    """The instance ID"""
+
+    initial: Optional[str]
+    """The initial message of the Widget integration"""
+
+    intro: Optional[str]
+    """The intro of the Widget integration"""
+
+    language: Optional[str]
+    """The language of the Widget integration"""
+
+    layout: Optional[str]
+    """The default layout of the Widget integration"""
+
+    math: Optional[bool]
+    """Whether the Widget integration supports math"""
+
+    maximize: Optional[bool]
+    """Controls whether the Widget allows maximizing the conversation"""
+
+    message_peek: Optional[bool]
+    """Controls whether the Widget allows peeking at the initial messages"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    origin: Optional[str]
+    """The origin URLs of the Widget integration"""
+
+    placeholder: Optional[str]
+    """The input placeholder of the Widget integration"""
+
+    plugins: Optional[str]
+    """The plugins of the Widget integration"""
+
+    powered_by: Optional[bool]
     """Whether the Widget integration displays powered by"""
 
     restart_conversation: Optional[bool]
@@ -32471,7 +32491,8 @@ class IntegrationWidgetListStreamItemData:
     voice_out: Optional[bool]
     """Whether the Widget integration supports voice output"""
 
-    def __init__(self, attachments: Optional[bool], auto_scroll: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], carousel: Optional[bool], contact_collection: Optional[bool], created_at: float, description: Optional[str], export_conversation: Optional[bool], form: Optional[bool], id: str, initial: Optional[str], intro: Optional[str], language: Optional[str], layout: Optional[str], math: Optional[bool], maximize: Optional[bool], message_peek: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], origin: Optional[str], placeholder: Optional[str], plugins: Optional[str], powered_by: Optional[bool], restart_conversation: Optional[bool], session_duration: Optional[float], start_first: Optional[bool], stream: Optional[bool], theme: Optional[str], title: Optional[str], tools: Optional[bool], unfurl: Optional[bool], updated_at: float, verbose: Optional[bool], voice_in: Optional[bool], voice_out: Optional[bool]) -> None:
+    def __init__(self, alias: Optional[str], attachments: Optional[bool], auto_scroll: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], carousel: Optional[bool], contact_collection: Optional[bool], created_at: float, description: Optional[str], export_conversation: Optional[bool], form: Optional[bool], id: str, initial: Optional[str], intro: Optional[str], language: Optional[str], layout: Optional[str], math: Optional[bool], maximize: Optional[bool], message_peek: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], origin: Optional[str], placeholder: Optional[str], plugins: Optional[str], powered_by: Optional[bool], restart_conversation: Optional[bool], session_duration: Optional[float], start_first: Optional[bool], stream: Optional[bool], theme: Optional[str], title: Optional[str], tools: Optional[bool], unfurl: Optional[bool], updated_at: float, verbose: Optional[bool], voice_in: Optional[bool], voice_out: Optional[bool]) -> None:
+        self.alias = alias
         self.attachments = attachments
         self.auto_scroll = auto_scroll
         self.blueprint_id = blueprint_id
@@ -32510,8 +32531,9 @@ def __init__(self, attachments: Optional[bool], auto_scroll: Optional[bool], blu
         self.voice_out = voice_out
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetListStreamItemData':
+    def from_dict(obj: Any) -> 'IntegrationWidgetFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         attachments = from_union([from_bool, from_none], obj.get("attachments"))
         auto_scroll = from_union([from_bool, from_none], obj.get("autoScroll"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
@@ -32548,10 +32570,12 @@ def from_dict(obj: Any) -> 'IntegrationWidgetListStreamItemData':
         verbose = from_union([from_bool, from_none], obj.get("verbose"))
         voice_in = from_union([from_bool, from_none], obj.get("voiceIn"))
         voice_out = from_union([from_bool, from_none], obj.get("voiceOut"))
-        return IntegrationWidgetListStreamItemData(attachments, auto_scroll, blueprint_id, bot_id, carousel, contact_collection, created_at, description, export_conversation, form, id, initial, intro, language, layout, math, maximize, message_peek, meta, name, origin, placeholder, plugins, powered_by, restart_conversation, session_duration, start_first, stream, theme, title, tools, unfurl, updated_at, verbose, voice_in, voice_out)
+        return IntegrationWidgetFetchResponse(alias, attachments, auto_scroll, blueprint_id, bot_id, carousel, contact_collection, created_at, description, export_conversation, form, id, initial, intro, language, layout, math, maximize, message_peek, meta, name, origin, placeholder, plugins, powered_by, restart_conversation, session_duration, start_first, stream, theme, title, tools, unfurl, updated_at, verbose, voice_in, voice_out)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.attachments is not None:
             result["attachments"] = from_union([from_bool, from_none], self.attachments)
         if self.auto_scroll is not None:
@@ -32624,207 +32648,1562 @@ def to_dict(self) -> dict:
         return result
 
 
-class IntegrationWidgetListStreamItemType(Enum):
-    """The type of event"""
-
-    ITEM = "item"
-
-
-class IntegrationWidgetListStreamItem:
-    data: IntegrationWidgetListStreamItemData
-    """A bot configuration that can be applied without a dedicated bot instance."""
+class WidgetIntegrationFileAttachParams:
+    file_id: str
+    """The ID of the file to attach"""
 
-    type: IntegrationWidgetListStreamItemType
-    """The type of event"""
+    widget_integration_id: str
+    """The ID of the widget integration"""
 
-    def __init__(self, data: IntegrationWidgetListStreamItemData, type: IntegrationWidgetListStreamItemType) -> None:
-        self.data = data
-        self.type = type
+    def __init__(self, file_id: str, widget_integration_id: str) -> None:
+        self.file_id = file_id
+        self.widget_integration_id = widget_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IntegrationWidgetListStreamItem':
+    def from_dict(obj: Any) -> 'WidgetIntegrationFileAttachParams':
         assert isinstance(obj, dict)
-        data = IntegrationWidgetListStreamItemData.from_dict(obj.get("data"))
-        type = IntegrationWidgetListStreamItemType(obj.get("type"))
-        return IntegrationWidgetListStreamItem(data, type)
+        file_id = from_str(obj.get("fileId"))
+        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
+        return WidgetIntegrationFileAttachParams(file_id, widget_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["data"] = to_class(IntegrationWidgetListStreamItemData, self.data)
-        result["type"] = to_enum(IntegrationWidgetListStreamItemType, self.type)
+        result["fileId"] = from_str(self.file_id)
+        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
         return result
 
 
-class MagicFromPromptGenerateParams:
-    prompt_id: str
-    """The ID of the prompt to use for generation"""
+class WidgetIntegrationFileAttachRequestType(Enum):
+    """The attachment slot type for the file"""
 
-    def __init__(self, prompt_id: str) -> None:
-        self.prompt_id = prompt_id
+    BAR = "bar"
+    BOT = "bot"
+    BUTTON = "button"
+    USER = "user"
+
+
+class WidgetIntegrationFileAttachRequest:
+    type: WidgetIntegrationFileAttachRequestType
+    """The attachment slot type for the file"""
+
+    def __init__(self, type: WidgetIntegrationFileAttachRequestType) -> None:
+        self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'MagicFromPromptGenerateParams':
+    def from_dict(obj: Any) -> 'WidgetIntegrationFileAttachRequest':
         assert isinstance(obj, dict)
-        prompt_id = from_str(obj.get("promptId"))
-        return MagicFromPromptGenerateParams(prompt_id)
+        type = WidgetIntegrationFileAttachRequestType(obj.get("type"))
+        return WidgetIntegrationFileAttachRequest(type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["promptId"] = from_str(self.prompt_id)
+        result["type"] = to_enum(WidgetIntegrationFileAttachRequestType, self.type)
         return result
 
 
-class MagicFromPromptGenerateRequest:
-    model: Optional[str]
-    """Optional language model to use for generation"""
+class WidgetIntegrationFileAttachResponse:
+    id: str
+    """The ID of the attached file"""
 
-    props: Optional[Dict[str, Any]]
-    """Additional properties to pass to the prompt"""
+    type: str
+    """The attachment slot type"""
 
-    text: str
-    """The text to use as input"""
+    widget_integration_id: str
+    """The ID of the widget integration"""
 
-    def __init__(self, model: Optional[str], props: Optional[Dict[str, Any]], text: str) -> None:
-        self.model = model
-        self.props = props
-        self.text = text
+    def __init__(self, id: str, type: str, widget_integration_id: str) -> None:
+        self.id = id
+        self.type = type
+        self.widget_integration_id = widget_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'MagicFromPromptGenerateRequest':
+    def from_dict(obj: Any) -> 'WidgetIntegrationFileAttachResponse':
         assert isinstance(obj, dict)
-        model = from_union([from_str, from_none], obj.get("model"))
-        props = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("props"))
-        text = from_str(obj.get("text"))
-        return MagicFromPromptGenerateRequest(model, props, text)
+        id = from_str(obj.get("id"))
+        type = from_str(obj.get("type"))
+        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
+        return WidgetIntegrationFileAttachResponse(id, type, widget_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.model is not None:
-            result["model"] = from_union([from_str, from_none], self.model)
-        if self.props is not None:
-            result["props"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.props)
-        result["text"] = from_str(self.text)
+        result["id"] = from_str(self.id)
+        result["type"] = from_str(self.type)
+        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
         return result
 
 
-class MagicFromPromptGenerateResponseUsage:
-    """Usage information"""
+class WidgetIntegrationFileDetachParams:
+    file_id: str
+    """The ID of the file to detach"""
 
-    token: float
-    """The tokens used in this exchange"""
+    widget_integration_id: str
+    """The ID of the widget integration"""
 
-    def __init__(self, token: float) -> None:
-        self.token = token
+    def __init__(self, file_id: str, widget_integration_id: str) -> None:
+        self.file_id = file_id
+        self.widget_integration_id = widget_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'MagicFromPromptGenerateResponseUsage':
+    def from_dict(obj: Any) -> 'WidgetIntegrationFileDetachParams':
         assert isinstance(obj, dict)
-        token = from_float(obj.get("token"))
-        return MagicFromPromptGenerateResponseUsage(token)
+        file_id = from_str(obj.get("fileId"))
+        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
+        return WidgetIntegrationFileDetachParams(file_id, widget_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["token"] = to_float(self.token)
+        result["fileId"] = from_str(self.file_id)
+        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
         return result
 
 
-class MagicFromPromptGenerateResponse:
-    text: str
-    """The input text"""
+class WidgetIntegrationFileDetachResponse:
+    id: str
+    """The ID of the detached file"""
 
-    usage: MagicFromPromptGenerateResponseUsage
-    """Usage information"""
+    type: str
+    """The attachment slot type that was cleared"""
 
-    def __init__(self, text: str, usage: MagicFromPromptGenerateResponseUsage) -> None:
-        self.text = text
-        self.usage = usage
+    widget_integration_id: str
+    """The ID of the widget integration"""
+
+    def __init__(self, id: str, type: str, widget_integration_id: str) -> None:
+        self.id = id
+        self.type = type
+        self.widget_integration_id = widget_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'MagicFromPromptGenerateResponse':
+    def from_dict(obj: Any) -> 'WidgetIntegrationFileDetachResponse':
         assert isinstance(obj, dict)
-        text = from_str(obj.get("text"))
-        usage = MagicFromPromptGenerateResponseUsage.from_dict(obj.get("usage"))
-        return MagicFromPromptGenerateResponse(text, usage)
+        id = from_str(obj.get("id"))
+        type = from_str(obj.get("type"))
+        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
+        return WidgetIntegrationFileDetachResponse(id, type, widget_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["text"] = from_str(self.text)
-        result["usage"] = to_class(MagicFromPromptGenerateResponseUsage, self.usage)
+        result["id"] = from_str(self.id)
+        result["type"] = from_str(self.type)
+        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
         return result
 
 
-class StickyUsage:
-    """Usage information"""
-
-    token: float
-    """The tokens used in this exchange"""
+class IntegrationWidgetSetupParams:
+    widget_integration_id: str
+    """The ID of the Widget integration"""
 
-    def __init__(self, token: float) -> None:
-        self.token = token
+    def __init__(self, widget_integration_id: str) -> None:
+        self.widget_integration_id = widget_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'StickyUsage':
+    def from_dict(obj: Any) -> 'IntegrationWidgetSetupParams':
         assert isinstance(obj, dict)
-        token = from_float(obj.get("token"))
-        return StickyUsage(token)
+        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
+        return IntegrationWidgetSetupParams(widget_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["token"] = to_float(self.token)
+        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
         return result
 
 
-class MagicFromPromptGenerateStreamItemData:
-    text: str
-    """The input text"""
-
-    usage: StickyUsage
-    """Usage information"""
+class IntegrationWidgetSetupResponse:
+    id: str
+    """The ID of the Widget integration"""
 
-    def __init__(self, text: str, usage: StickyUsage) -> None:
-        self.text = text
-        self.usage = usage
+    def __init__(self, id: str) -> None:
+        self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'MagicFromPromptGenerateStreamItemData':
+    def from_dict(obj: Any) -> 'IntegrationWidgetSetupResponse':
         assert isinstance(obj, dict)
-        text = from_str(obj.get("text"))
-        usage = StickyUsage.from_dict(obj.get("usage"))
-        return MagicFromPromptGenerateStreamItemData(text, usage)
+        id = from_str(obj.get("id"))
+        return IntegrationWidgetSetupResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["text"] = from_str(self.text)
-        result["usage"] = to_class(StickyUsage, self.usage)
+        result["id"] = from_str(self.id)
         return result
 
 
-class MagicFromPromptGenerateStreamItemType(Enum):
-    """The generated text"""
-
-    RESULT = "result"
-
-
-class MagicFromPromptGenerateStreamItem:
-    data: MagicFromPromptGenerateStreamItemData
-    type: MagicFromPromptGenerateStreamItemType
-    """The generated text"""
+class IntegrationWidgetUpdateParams:
+    widget_integration_id: str
+    """The ID of the Widget integration"""
 
-    def __init__(self, data: MagicFromPromptGenerateStreamItemData, type: MagicFromPromptGenerateStreamItemType) -> None:
-        self.data = data
-        self.type = type
+    def __init__(self, widget_integration_id: str) -> None:
+        self.widget_integration_id = widget_integration_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'MagicFromPromptGenerateStreamItem':
+    def from_dict(obj: Any) -> 'IntegrationWidgetUpdateParams':
         assert isinstance(obj, dict)
-        data = MagicFromPromptGenerateStreamItemData.from_dict(obj.get("data"))
-        type = MagicFromPromptGenerateStreamItemType(obj.get("type"))
-        return MagicFromPromptGenerateStreamItem(data, type)
+        widget_integration_id = from_str(obj.get("widgetIntegrationId"))
+        return IntegrationWidgetUpdateParams(widget_integration_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["data"] = to_class(MagicFromPromptGenerateStreamItemData, self.data)
-        result["type"] = to_enum(MagicFromPromptGenerateStreamItemType, self.type)
+        result["widgetIntegrationId"] = from_str(self.widget_integration_id)
+        return result
+
+
+class IntegrationWidgetUpdateRequest:
+    """A bot configuration that can be applied without a dedicated bot instance."""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    attachments: Optional[bool]
+    """Whether the Widget integration supports attachments"""
+
+    auto_scroll: Optional[bool]
+    """Whether the Widget integration auto scrolls"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    bot_id: Optional[str]
+    """The ID of the bot this configuration is using"""
+
+    carousel: Optional[bool]
+    """Whether the Widget integration supports carousels"""
+
+    contact_collection: Optional[bool]
+    """Whether the Widget integration collects contacts"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    export_conversation: Optional[bool]
+    """Controls whether the Widget allows exporting the current conversation"""
+
+    form: Optional[bool]
+    """Whether the Widget integration supports forms"""
+
+    initial: Optional[str]
+    """The initial message of the Widget integration"""
+
+    intro: Optional[str]
+    """The intro of the Widget integration"""
+
+    language: Optional[str]
+    """The language of the Widget integration"""
+
+    layout: Optional[str]
+    """The default layout of the Widget integration"""
+
+    math: Optional[bool]
+    """Whether the Widget integration supports math"""
+
+    maximize: Optional[bool]
+    """Controls whether the Widget allows maximizing the conversation"""
+
+    message_peek: Optional[bool]
+    """Controls whether the Widget allows peeking at the initial messages"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    origin: Optional[str]
+    """The origin URLs of the Widget integration"""
+
+    placeholder: Optional[str]
+    """The input placeholder of the Widget integration"""
+
+    plugins: Optional[str]
+    """The plugins of the Widget integration"""
+
+    powered_by: Optional[bool]
+    """Whether the Widget integration displays powered by"""
+
+    restart_conversation: Optional[bool]
+    """Controls whether the Widget allows restarting the conversation"""
+
+    session_duration: Optional[float]
+    """The session duration of the Widget integration"""
+
+    start_first: Optional[bool]
+    """Whether the Widget integration starts first"""
+
+    stream: Optional[bool]
+    """Whether the Widget integration is streaming"""
+
+    theme: Optional[str]
+    """The theme of the Widget integration"""
+
+    title: Optional[str]
+    """The title of the Widget integration"""
+
+    tools: Optional[bool]
+    """Whether the Widget integration has tools"""
+
+    unfurl: Optional[bool]
+    """Whether the Widget integration unfurls links"""
+
+    verbose: Optional[bool]
+    """Whether the Widget integration is verbose"""
+
+    voice_in: Optional[bool]
+    """Controls whether the Widget allows voice input"""
+
+    voice_out: Optional[bool]
+    """Controls whether the Widget allows voice output"""
+
+    def __init__(self, alias: Optional[str], attachments: Optional[bool], auto_scroll: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], carousel: Optional[bool], contact_collection: Optional[bool], description: Optional[str], export_conversation: Optional[bool], form: Optional[bool], initial: Optional[str], intro: Optional[str], language: Optional[str], layout: Optional[str], math: Optional[bool], maximize: Optional[bool], message_peek: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], origin: Optional[str], placeholder: Optional[str], plugins: Optional[str], powered_by: Optional[bool], restart_conversation: Optional[bool], session_duration: Optional[float], start_first: Optional[bool], stream: Optional[bool], theme: Optional[str], title: Optional[str], tools: Optional[bool], unfurl: Optional[bool], verbose: Optional[bool], voice_in: Optional[bool], voice_out: Optional[bool]) -> None:
+        self.alias = alias
+        self.attachments = attachments
+        self.auto_scroll = auto_scroll
+        self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
+        self.carousel = carousel
+        self.contact_collection = contact_collection
+        self.description = description
+        self.export_conversation = export_conversation
+        self.form = form
+        self.initial = initial
+        self.intro = intro
+        self.language = language
+        self.layout = layout
+        self.math = math
+        self.maximize = maximize
+        self.message_peek = message_peek
+        self.meta = meta
+        self.name = name
+        self.origin = origin
+        self.placeholder = placeholder
+        self.plugins = plugins
+        self.powered_by = powered_by
+        self.restart_conversation = restart_conversation
+        self.session_duration = session_duration
+        self.start_first = start_first
+        self.stream = stream
+        self.theme = theme
+        self.title = title
+        self.tools = tools
+        self.unfurl = unfurl
+        self.verbose = verbose
+        self.voice_in = voice_in
+        self.voice_out = voice_out
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetUpdateRequest':
+        assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        attachments = from_union([from_bool, from_none], obj.get("attachments"))
+        auto_scroll = from_union([from_bool, from_none], obj.get("autoScroll"))
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        carousel = from_union([from_bool, from_none], obj.get("carousel"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        export_conversation = from_union([from_bool, from_none], obj.get("exportConversation"))
+        form = from_union([from_bool, from_none], obj.get("form"))
+        initial = from_union([from_str, from_none], obj.get("initial"))
+        intro = from_union([from_str, from_none], obj.get("intro"))
+        language = from_union([from_str, from_none], obj.get("language"))
+        layout = from_union([from_str, from_none], obj.get("layout"))
+        math = from_union([from_bool, from_none], obj.get("math"))
+        maximize = from_union([from_bool, from_none], obj.get("maximize"))
+        message_peek = from_union([from_bool, from_none], obj.get("messagePeek"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        origin = from_union([from_str, from_none], obj.get("origin"))
+        placeholder = from_union([from_str, from_none], obj.get("placeholder"))
+        plugins = from_union([from_str, from_none], obj.get("plugins"))
+        powered_by = from_union([from_bool, from_none], obj.get("poweredBy"))
+        restart_conversation = from_union([from_bool, from_none], obj.get("restartConversation"))
+        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        start_first = from_union([from_bool, from_none], obj.get("startFirst"))
+        stream = from_union([from_bool, from_none], obj.get("stream"))
+        theme = from_union([from_str, from_none], obj.get("theme"))
+        title = from_union([from_str, from_none], obj.get("title"))
+        tools = from_union([from_bool, from_none], obj.get("tools"))
+        unfurl = from_union([from_bool, from_none], obj.get("unfurl"))
+        verbose = from_union([from_bool, from_none], obj.get("verbose"))
+        voice_in = from_union([from_bool, from_none], obj.get("voiceIn"))
+        voice_out = from_union([from_bool, from_none], obj.get("voiceOut"))
+        return IntegrationWidgetUpdateRequest(alias, attachments, auto_scroll, blueprint_id, bot_id, carousel, contact_collection, description, export_conversation, form, initial, intro, language, layout, math, maximize, message_peek, meta, name, origin, placeholder, plugins, powered_by, restart_conversation, session_duration, start_first, stream, theme, title, tools, unfurl, verbose, voice_in, voice_out)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.attachments is not None:
+            result["attachments"] = from_union([from_bool, from_none], self.attachments)
+        if self.auto_scroll is not None:
+            result["autoScroll"] = from_union([from_bool, from_none], self.auto_scroll)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.carousel is not None:
+            result["carousel"] = from_union([from_bool, from_none], self.carousel)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        if self.export_conversation is not None:
+            result["exportConversation"] = from_union([from_bool, from_none], self.export_conversation)
+        if self.form is not None:
+            result["form"] = from_union([from_bool, from_none], self.form)
+        if self.initial is not None:
+            result["initial"] = from_union([from_str, from_none], self.initial)
+        if self.intro is not None:
+            result["intro"] = from_union([from_str, from_none], self.intro)
+        if self.language is not None:
+            result["language"] = from_union([from_str, from_none], self.language)
+        if self.layout is not None:
+            result["layout"] = from_union([from_str, from_none], self.layout)
+        if self.math is not None:
+            result["math"] = from_union([from_bool, from_none], self.math)
+        if self.maximize is not None:
+            result["maximize"] = from_union([from_bool, from_none], self.maximize)
+        if self.message_peek is not None:
+            result["messagePeek"] = from_union([from_bool, from_none], self.message_peek)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.origin is not None:
+            result["origin"] = from_union([from_str, from_none], self.origin)
+        if self.placeholder is not None:
+            result["placeholder"] = from_union([from_str, from_none], self.placeholder)
+        if self.plugins is not None:
+            result["plugins"] = from_union([from_str, from_none], self.plugins)
+        if self.powered_by is not None:
+            result["poweredBy"] = from_union([from_bool, from_none], self.powered_by)
+        if self.restart_conversation is not None:
+            result["restartConversation"] = from_union([from_bool, from_none], self.restart_conversation)
+        if self.session_duration is not None:
+            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.start_first is not None:
+            result["startFirst"] = from_union([from_bool, from_none], self.start_first)
+        if self.stream is not None:
+            result["stream"] = from_union([from_bool, from_none], self.stream)
+        if self.theme is not None:
+            result["theme"] = from_union([from_str, from_none], self.theme)
+        if self.title is not None:
+            result["title"] = from_union([from_str, from_none], self.title)
+        if self.tools is not None:
+            result["tools"] = from_union([from_bool, from_none], self.tools)
+        if self.unfurl is not None:
+            result["unfurl"] = from_union([from_bool, from_none], self.unfurl)
+        if self.verbose is not None:
+            result["verbose"] = from_union([from_bool, from_none], self.verbose)
+        if self.voice_in is not None:
+            result["voiceIn"] = from_union([from_bool, from_none], self.voice_in)
+        if self.voice_out is not None:
+            result["voiceOut"] = from_union([from_bool, from_none], self.voice_out)
+        return result
+
+
+class IntegrationWidgetUpdateResponse:
+    id: str
+    """The ID of the Widget Integration"""
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetUpdateResponse':
+        assert isinstance(obj, dict)
+        id = from_str(obj.get("id"))
+        return IntegrationWidgetUpdateResponse(id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["id"] = from_str(self.id)
+        return result
+
+
+class IntegrationWidgetCreateRequest:
+    """A bot configuration that can be applied without a dedicated bot instance."""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    attachments: Optional[bool]
+    """Weather the Widget integration supports attachments"""
+
+    auto_scroll: Optional[bool]
+    """Whether the Widget integration auto scrolls"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    bot_id: Optional[str]
+    """The ID of the bot this configuration is using"""
+
+    carousel: Optional[bool]
+    """Weather the Widget integration supports carousels"""
+
+    contact_collection: Optional[bool]
+    """Whether the Widget integration collects contacts"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    export_conversation: Optional[bool]
+    """Controls whether the Widget allows exporting the current conversation"""
+
+    form: Optional[bool]
+    """Weather the Widget integration supports forms"""
+
+    initial: Optional[str]
+    """The initial message of the Widget integration"""
+
+    intro: Optional[str]
+    """The intro of the Widget integration"""
+
+    language: Optional[str]
+    """The language of the Widget integration"""
+
+    layout: Optional[str]
+    """The default layout of the Widget integration"""
+
+    math: Optional[bool]
+    """Weather the Widget integration supports math"""
+
+    maximize: Optional[bool]
+    """Controls whether the Widget allows maximizing the conversation"""
+
+    message_peek: Optional[bool]
+    """Controls whether the Widget allows peeking at the initial messages"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    origin: Optional[str]
+    """The origin URLs of the Widget integration"""
+
+    placeholder: Optional[str]
+    """The input placeholder of the Widget integration"""
+
+    plugins: Optional[str]
+    """The plugins of the Widget integration"""
+
+    powered_by: Optional[bool]
+    """Whether the Widget integration displays powered by"""
+
+    restart_conversation: Optional[bool]
+    """Controls whether the Widget allows restarting the conversation"""
+
+    session_duration: Optional[float]
+    """The session duration of the Widget integration"""
+
+    start_first: Optional[bool]
+    """Whether the Widget integration starts first"""
+
+    stream: Optional[bool]
+    """Whether the Widget integration is streaming"""
+
+    theme: Optional[str]
+    """The theme of the Widget integration"""
+
+    title: Optional[str]
+    """The title of the Widget integration"""
+
+    tools: Optional[bool]
+    """Whether the Widget integration has tools"""
+
+    unfurl: Optional[bool]
+    """Whether the Widget integration unfurls links"""
+
+    verbose: Optional[bool]
+    """Whether the Widget integration is verbose"""
+
+    voice_in: Optional[bool]
+    """Controls whether the Widget allows voice input"""
+
+    voice_out: Optional[bool]
+    """Controls whether the Widget allows voice output"""
+
+    def __init__(self, alias: Optional[str], attachments: Optional[bool], auto_scroll: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], carousel: Optional[bool], contact_collection: Optional[bool], description: Optional[str], export_conversation: Optional[bool], form: Optional[bool], initial: Optional[str], intro: Optional[str], language: Optional[str], layout: Optional[str], math: Optional[bool], maximize: Optional[bool], message_peek: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], origin: Optional[str], placeholder: Optional[str], plugins: Optional[str], powered_by: Optional[bool], restart_conversation: Optional[bool], session_duration: Optional[float], start_first: Optional[bool], stream: Optional[bool], theme: Optional[str], title: Optional[str], tools: Optional[bool], unfurl: Optional[bool], verbose: Optional[bool], voice_in: Optional[bool], voice_out: Optional[bool]) -> None:
+        self.alias = alias
+        self.attachments = attachments
+        self.auto_scroll = auto_scroll
+        self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
+        self.carousel = carousel
+        self.contact_collection = contact_collection
+        self.description = description
+        self.export_conversation = export_conversation
+        self.form = form
+        self.initial = initial
+        self.intro = intro
+        self.language = language
+        self.layout = layout
+        self.math = math
+        self.maximize = maximize
+        self.message_peek = message_peek
+        self.meta = meta
+        self.name = name
+        self.origin = origin
+        self.placeholder = placeholder
+        self.plugins = plugins
+        self.powered_by = powered_by
+        self.restart_conversation = restart_conversation
+        self.session_duration = session_duration
+        self.start_first = start_first
+        self.stream = stream
+        self.theme = theme
+        self.title = title
+        self.tools = tools
+        self.unfurl = unfurl
+        self.verbose = verbose
+        self.voice_in = voice_in
+        self.voice_out = voice_out
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetCreateRequest':
+        assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        attachments = from_union([from_bool, from_none], obj.get("attachments"))
+        auto_scroll = from_union([from_bool, from_none], obj.get("autoScroll"))
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        carousel = from_union([from_bool, from_none], obj.get("carousel"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        export_conversation = from_union([from_bool, from_none], obj.get("exportConversation"))
+        form = from_union([from_bool, from_none], obj.get("form"))
+        initial = from_union([from_str, from_none], obj.get("initial"))
+        intro = from_union([from_str, from_none], obj.get("intro"))
+        language = from_union([from_str, from_none], obj.get("language"))
+        layout = from_union([from_str, from_none], obj.get("layout"))
+        math = from_union([from_bool, from_none], obj.get("math"))
+        maximize = from_union([from_bool, from_none], obj.get("maximize"))
+        message_peek = from_union([from_bool, from_none], obj.get("messagePeek"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        origin = from_union([from_str, from_none], obj.get("origin"))
+        placeholder = from_union([from_str, from_none], obj.get("placeholder"))
+        plugins = from_union([from_str, from_none], obj.get("plugins"))
+        powered_by = from_union([from_bool, from_none], obj.get("poweredBy"))
+        restart_conversation = from_union([from_bool, from_none], obj.get("restartConversation"))
+        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        start_first = from_union([from_bool, from_none], obj.get("startFirst"))
+        stream = from_union([from_bool, from_none], obj.get("stream"))
+        theme = from_union([from_str, from_none], obj.get("theme"))
+        title = from_union([from_str, from_none], obj.get("title"))
+        tools = from_union([from_bool, from_none], obj.get("tools"))
+        unfurl = from_union([from_bool, from_none], obj.get("unfurl"))
+        verbose = from_union([from_bool, from_none], obj.get("verbose"))
+        voice_in = from_union([from_bool, from_none], obj.get("voiceIn"))
+        voice_out = from_union([from_bool, from_none], obj.get("voiceOut"))
+        return IntegrationWidgetCreateRequest(alias, attachments, auto_scroll, blueprint_id, bot_id, carousel, contact_collection, description, export_conversation, form, initial, intro, language, layout, math, maximize, message_peek, meta, name, origin, placeholder, plugins, powered_by, restart_conversation, session_duration, start_first, stream, theme, title, tools, unfurl, verbose, voice_in, voice_out)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.attachments is not None:
+            result["attachments"] = from_union([from_bool, from_none], self.attachments)
+        if self.auto_scroll is not None:
+            result["autoScroll"] = from_union([from_bool, from_none], self.auto_scroll)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.carousel is not None:
+            result["carousel"] = from_union([from_bool, from_none], self.carousel)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        if self.export_conversation is not None:
+            result["exportConversation"] = from_union([from_bool, from_none], self.export_conversation)
+        if self.form is not None:
+            result["form"] = from_union([from_bool, from_none], self.form)
+        if self.initial is not None:
+            result["initial"] = from_union([from_str, from_none], self.initial)
+        if self.intro is not None:
+            result["intro"] = from_union([from_str, from_none], self.intro)
+        if self.language is not None:
+            result["language"] = from_union([from_str, from_none], self.language)
+        if self.layout is not None:
+            result["layout"] = from_union([from_str, from_none], self.layout)
+        if self.math is not None:
+            result["math"] = from_union([from_bool, from_none], self.math)
+        if self.maximize is not None:
+            result["maximize"] = from_union([from_bool, from_none], self.maximize)
+        if self.message_peek is not None:
+            result["messagePeek"] = from_union([from_bool, from_none], self.message_peek)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.origin is not None:
+            result["origin"] = from_union([from_str, from_none], self.origin)
+        if self.placeholder is not None:
+            result["placeholder"] = from_union([from_str, from_none], self.placeholder)
+        if self.plugins is not None:
+            result["plugins"] = from_union([from_str, from_none], self.plugins)
+        if self.powered_by is not None:
+            result["poweredBy"] = from_union([from_bool, from_none], self.powered_by)
+        if self.restart_conversation is not None:
+            result["restartConversation"] = from_union([from_bool, from_none], self.restart_conversation)
+        if self.session_duration is not None:
+            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.start_first is not None:
+            result["startFirst"] = from_union([from_bool, from_none], self.start_first)
+        if self.stream is not None:
+            result["stream"] = from_union([from_bool, from_none], self.stream)
+        if self.theme is not None:
+            result["theme"] = from_union([from_str, from_none], self.theme)
+        if self.title is not None:
+            result["title"] = from_union([from_str, from_none], self.title)
+        if self.tools is not None:
+            result["tools"] = from_union([from_bool, from_none], self.tools)
+        if self.unfurl is not None:
+            result["unfurl"] = from_union([from_bool, from_none], self.unfurl)
+        if self.verbose is not None:
+            result["verbose"] = from_union([from_bool, from_none], self.verbose)
+        if self.voice_in is not None:
+            result["voiceIn"] = from_union([from_bool, from_none], self.voice_in)
+        if self.voice_out is not None:
+            result["voiceOut"] = from_union([from_bool, from_none], self.voice_out)
+        return result
+
+
+class IntegrationWidgetCreateResponse:
+    id: str
+    """The ID of the Widget Integration"""
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetCreateResponse':
+        assert isinstance(obj, dict)
+        id = from_str(obj.get("id"))
+        return IntegrationWidgetCreateResponse(id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["id"] = from_str(self.id)
+        return result
+
+
+class IntegrationWidgetListParamsOrder(Enum):
+    """The order of the paginated items"""
+
+    ASC = "asc"
+    DESC = "desc"
+
+
+class IntegrationWidgetListParams:
+    cursor: Optional[str]
+    """The cursor to use for pagination"""
+
+    meta: Optional[Dict[str, str]]
+    """Key-value pairs to filter the partner users by metadata"""
+
+    order: Optional[IntegrationWidgetListParamsOrder]
+    """The order of the paginated items"""
+
+    take: Optional[int]
+    """The number of items to retrieve"""
+
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[IntegrationWidgetListParamsOrder], take: Optional[int]) -> None:
+        self.cursor = cursor
+        self.meta = meta
+        self.order = order
+        self.take = take
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetListParams':
+        assert isinstance(obj, dict)
+        cursor = from_union([from_str, from_none], obj.get("cursor"))
+        meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
+        order = from_union([IntegrationWidgetListParamsOrder, from_none], obj.get("order"))
+        take = from_union([from_int, from_none], obj.get("take"))
+        return IntegrationWidgetListParams(cursor, meta, order, take)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.cursor is not None:
+            result["cursor"] = from_union([from_str, from_none], self.cursor)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
+        if self.order is not None:
+            result["order"] = from_union([lambda x: to_enum(IntegrationWidgetListParamsOrder, x), from_none], self.order)
+        if self.take is not None:
+            result["take"] = from_union([from_int, from_none], self.take)
+        return result
+
+
+class IntegrationWidgetListResponseItem:
+    """A bot configuration that can be applied without a dedicated bot instance."""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    attachments: Optional[bool]
+    """Weather the Widget integration supports attachments"""
+
+    auto_scroll: Optional[bool]
+    """Whether the Widget integration auto scrolls"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    bot_id: Optional[str]
+    """The ID of the bot this configuration is using"""
+
+    carousel: Optional[bool]
+    """Weather the Widget integration supports carousels"""
+
+    contact_collection: Optional[bool]
+    """Whether the Widget integration collects contacts"""
+
+    created_at: float
+    """The timestamp (ms) when the instance was created"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    export_conversation: Optional[bool]
+    """Controls whether the Widget allows exporting the current conversation"""
+
+    form: Optional[bool]
+    """Weather the Widget integration supports forms"""
+
+    id: str
+    """The instance ID"""
+
+    initial: Optional[str]
+    """The initial message of the Widget integration"""
+
+    intro: Optional[str]
+    """The intro of the Widget integration"""
+
+    language: Optional[str]
+    """The language of the Widget integration"""
+
+    layout: Optional[str]
+    """The default layout of the Widget integration"""
+
+    math: Optional[bool]
+    """Weather the Widget integration supports math"""
+
+    maximize: Optional[bool]
+    """Controls whether the Widget allows maximizing the conversation"""
+
+    message_peek: Optional[bool]
+    """Controls whether the Widget allows peeking at the initial messages"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    origin: Optional[str]
+    """The origin URLs of the Widget integration"""
+
+    placeholder: Optional[str]
+    """The input placeholder of the Widget integration"""
+
+    plugins: Optional[str]
+    """The plugins of the Widget integration"""
+
+    powered_by: Optional[bool]
+    """Whether the Widget integration displays powered by"""
+
+    restart_conversation: Optional[bool]
+    """Controls whether the Widget allows restarting the conversation"""
+
+    session_duration: Optional[float]
+    """The session duration of the Widget integration"""
+
+    start_first: Optional[bool]
+    """Whether the Widget integration starts first"""
+
+    stream: Optional[bool]
+    """Whether the Widget integration is streaming"""
+
+    theme: Optional[str]
+    """The theme of the Widget integration"""
+
+    title: Optional[str]
+    """The title of the Widget integration"""
+
+    tools: Optional[bool]
+    """Whether the Widget integration has tools"""
+
+    unfurl: Optional[bool]
+    """Whether the Widget integration unfurls links"""
+
+    updated_at: float
+    """The timestamp (ms) when the instance was updated"""
+
+    verbose: Optional[bool]
+    """Whether the Widget integration is verbose"""
+
+    voice_in: Optional[bool]
+    """Whether the Widget integration supports voice input"""
+
+    voice_out: Optional[bool]
+    """Whether the Widget integration supports voice output"""
+
+    def __init__(self, alias: Optional[str], attachments: Optional[bool], auto_scroll: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], carousel: Optional[bool], contact_collection: Optional[bool], created_at: float, description: Optional[str], export_conversation: Optional[bool], form: Optional[bool], id: str, initial: Optional[str], intro: Optional[str], language: Optional[str], layout: Optional[str], math: Optional[bool], maximize: Optional[bool], message_peek: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], origin: Optional[str], placeholder: Optional[str], plugins: Optional[str], powered_by: Optional[bool], restart_conversation: Optional[bool], session_duration: Optional[float], start_first: Optional[bool], stream: Optional[bool], theme: Optional[str], title: Optional[str], tools: Optional[bool], unfurl: Optional[bool], updated_at: float, verbose: Optional[bool], voice_in: Optional[bool], voice_out: Optional[bool]) -> None:
+        self.alias = alias
+        self.attachments = attachments
+        self.auto_scroll = auto_scroll
+        self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
+        self.carousel = carousel
+        self.contact_collection = contact_collection
+        self.created_at = created_at
+        self.description = description
+        self.export_conversation = export_conversation
+        self.form = form
+        self.id = id
+        self.initial = initial
+        self.intro = intro
+        self.language = language
+        self.layout = layout
+        self.math = math
+        self.maximize = maximize
+        self.message_peek = message_peek
+        self.meta = meta
+        self.name = name
+        self.origin = origin
+        self.placeholder = placeholder
+        self.plugins = plugins
+        self.powered_by = powered_by
+        self.restart_conversation = restart_conversation
+        self.session_duration = session_duration
+        self.start_first = start_first
+        self.stream = stream
+        self.theme = theme
+        self.title = title
+        self.tools = tools
+        self.unfurl = unfurl
+        self.updated_at = updated_at
+        self.verbose = verbose
+        self.voice_in = voice_in
+        self.voice_out = voice_out
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetListResponseItem':
+        assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        attachments = from_union([from_bool, from_none], obj.get("attachments"))
+        auto_scroll = from_union([from_bool, from_none], obj.get("autoScroll"))
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        carousel = from_union([from_bool, from_none], obj.get("carousel"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
+        created_at = from_float(obj.get("createdAt"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        export_conversation = from_union([from_bool, from_none], obj.get("exportConversation"))
+        form = from_union([from_bool, from_none], obj.get("form"))
+        id = from_str(obj.get("id"))
+        initial = from_union([from_str, from_none], obj.get("initial"))
+        intro = from_union([from_str, from_none], obj.get("intro"))
+        language = from_union([from_str, from_none], obj.get("language"))
+        layout = from_union([from_str, from_none], obj.get("layout"))
+        math = from_union([from_bool, from_none], obj.get("math"))
+        maximize = from_union([from_bool, from_none], obj.get("maximize"))
+        message_peek = from_union([from_bool, from_none], obj.get("messagePeek"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        origin = from_union([from_str, from_none], obj.get("origin"))
+        placeholder = from_union([from_str, from_none], obj.get("placeholder"))
+        plugins = from_union([from_str, from_none], obj.get("plugins"))
+        powered_by = from_union([from_bool, from_none], obj.get("poweredBy"))
+        restart_conversation = from_union([from_bool, from_none], obj.get("restartConversation"))
+        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        start_first = from_union([from_bool, from_none], obj.get("startFirst"))
+        stream = from_union([from_bool, from_none], obj.get("stream"))
+        theme = from_union([from_str, from_none], obj.get("theme"))
+        title = from_union([from_str, from_none], obj.get("title"))
+        tools = from_union([from_bool, from_none], obj.get("tools"))
+        unfurl = from_union([from_bool, from_none], obj.get("unfurl"))
+        updated_at = from_float(obj.get("updatedAt"))
+        verbose = from_union([from_bool, from_none], obj.get("verbose"))
+        voice_in = from_union([from_bool, from_none], obj.get("voiceIn"))
+        voice_out = from_union([from_bool, from_none], obj.get("voiceOut"))
+        return IntegrationWidgetListResponseItem(alias, attachments, auto_scroll, blueprint_id, bot_id, carousel, contact_collection, created_at, description, export_conversation, form, id, initial, intro, language, layout, math, maximize, message_peek, meta, name, origin, placeholder, plugins, powered_by, restart_conversation, session_duration, start_first, stream, theme, title, tools, unfurl, updated_at, verbose, voice_in, voice_out)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.attachments is not None:
+            result["attachments"] = from_union([from_bool, from_none], self.attachments)
+        if self.auto_scroll is not None:
+            result["autoScroll"] = from_union([from_bool, from_none], self.auto_scroll)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.carousel is not None:
+            result["carousel"] = from_union([from_bool, from_none], self.carousel)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
+        result["createdAt"] = to_float(self.created_at)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        if self.export_conversation is not None:
+            result["exportConversation"] = from_union([from_bool, from_none], self.export_conversation)
+        if self.form is not None:
+            result["form"] = from_union([from_bool, from_none], self.form)
+        result["id"] = from_str(self.id)
+        if self.initial is not None:
+            result["initial"] = from_union([from_str, from_none], self.initial)
+        if self.intro is not None:
+            result["intro"] = from_union([from_str, from_none], self.intro)
+        if self.language is not None:
+            result["language"] = from_union([from_str, from_none], self.language)
+        if self.layout is not None:
+            result["layout"] = from_union([from_str, from_none], self.layout)
+        if self.math is not None:
+            result["math"] = from_union([from_bool, from_none], self.math)
+        if self.maximize is not None:
+            result["maximize"] = from_union([from_bool, from_none], self.maximize)
+        if self.message_peek is not None:
+            result["messagePeek"] = from_union([from_bool, from_none], self.message_peek)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.origin is not None:
+            result["origin"] = from_union([from_str, from_none], self.origin)
+        if self.placeholder is not None:
+            result["placeholder"] = from_union([from_str, from_none], self.placeholder)
+        if self.plugins is not None:
+            result["plugins"] = from_union([from_str, from_none], self.plugins)
+        if self.powered_by is not None:
+            result["poweredBy"] = from_union([from_bool, from_none], self.powered_by)
+        if self.restart_conversation is not None:
+            result["restartConversation"] = from_union([from_bool, from_none], self.restart_conversation)
+        if self.session_duration is not None:
+            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.start_first is not None:
+            result["startFirst"] = from_union([from_bool, from_none], self.start_first)
+        if self.stream is not None:
+            result["stream"] = from_union([from_bool, from_none], self.stream)
+        if self.theme is not None:
+            result["theme"] = from_union([from_str, from_none], self.theme)
+        if self.title is not None:
+            result["title"] = from_union([from_str, from_none], self.title)
+        if self.tools is not None:
+            result["tools"] = from_union([from_bool, from_none], self.tools)
+        if self.unfurl is not None:
+            result["unfurl"] = from_union([from_bool, from_none], self.unfurl)
+        result["updatedAt"] = to_float(self.updated_at)
+        if self.verbose is not None:
+            result["verbose"] = from_union([from_bool, from_none], self.verbose)
+        if self.voice_in is not None:
+            result["voiceIn"] = from_union([from_bool, from_none], self.voice_in)
+        if self.voice_out is not None:
+            result["voiceOut"] = from_union([from_bool, from_none], self.voice_out)
+        return result
+
+
+class IntegrationWidgetListResponse:
+    cursor: str
+    """Cursor for fetching the next page"""
+
+    items: List[IntegrationWidgetListResponseItem]
+
+    def __init__(self, cursor: str, items: List[IntegrationWidgetListResponseItem]) -> None:
+        self.cursor = cursor
+        self.items = items
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetListResponse':
+        assert isinstance(obj, dict)
+        cursor = from_str(obj.get("cursor"))
+        items = from_list(IntegrationWidgetListResponseItem.from_dict, obj.get("items"))
+        return IntegrationWidgetListResponse(cursor, items)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["cursor"] = from_str(self.cursor)
+        result["items"] = from_list(lambda x: to_class(IntegrationWidgetListResponseItem, x), self.items)
+        return result
+
+
+class IntegrationWidgetListStreamItemData:
+    """A bot configuration that can be applied without a dedicated bot instance."""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    attachments: Optional[bool]
+    """Weather the Widget integration supports attachments"""
+
+    auto_scroll: Optional[bool]
+    """Whether the Widget integration auto scrolls"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    bot_id: Optional[str]
+    """The ID of the bot this configuration is using"""
+
+    carousel: Optional[bool]
+    """Weather the Widget integration supports carousels"""
+
+    contact_collection: Optional[bool]
+    """Whether the Widget integration collects contacts"""
+
+    created_at: float
+    """The timestamp (ms) when the instance was created"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    export_conversation: Optional[bool]
+    """Controls whether the Widget allows exporting the current conversation"""
+
+    form: Optional[bool]
+    """Weather the Widget integration supports forms"""
+
+    id: str
+    """The instance ID"""
+
+    initial: Optional[str]
+    """The initial message of the Widget integration"""
+
+    intro: Optional[str]
+    """The intro of the Widget integration"""
+
+    language: Optional[str]
+    """The language of the Widget integration"""
+
+    layout: Optional[str]
+    """The default layout of the Widget integration"""
+
+    math: Optional[bool]
+    """Weather the Widget integration supports math"""
+
+    maximize: Optional[bool]
+    """Controls whether the Widget allows maximizing the conversation"""
+
+    message_peek: Optional[bool]
+    """Controls whether the Widget allows peeking at the initial messages"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    origin: Optional[str]
+    """The origin URLs of the Widget integration"""
+
+    placeholder: Optional[str]
+    """The input placeholder of the Widget integration"""
+
+    plugins: Optional[str]
+    """The plugins of the Widget integration"""
+
+    powered_by: Optional[bool]
+    """Whether the Widget integration displays powered by"""
+
+    restart_conversation: Optional[bool]
+    """Controls whether the Widget allows restarting the conversation"""
+
+    session_duration: Optional[float]
+    """The session duration of the Widget integration"""
+
+    start_first: Optional[bool]
+    """Whether the Widget integration starts first"""
+
+    stream: Optional[bool]
+    """Whether the Widget integration is streaming"""
+
+    theme: Optional[str]
+    """The theme of the Widget integration"""
+
+    title: Optional[str]
+    """The title of the Widget integration"""
+
+    tools: Optional[bool]
+    """Whether the Widget integration has tools"""
+
+    unfurl: Optional[bool]
+    """Whether the Widget integration unfurls links"""
+
+    updated_at: float
+    """The timestamp (ms) when the instance was updated"""
+
+    verbose: Optional[bool]
+    """Whether the Widget integration is verbose"""
+
+    voice_in: Optional[bool]
+    """Whether the Widget integration supports voice input"""
+
+    voice_out: Optional[bool]
+    """Whether the Widget integration supports voice output"""
+
+    def __init__(self, alias: Optional[str], attachments: Optional[bool], auto_scroll: Optional[bool], blueprint_id: Optional[str], bot_id: Optional[str], carousel: Optional[bool], contact_collection: Optional[bool], created_at: float, description: Optional[str], export_conversation: Optional[bool], form: Optional[bool], id: str, initial: Optional[str], intro: Optional[str], language: Optional[str], layout: Optional[str], math: Optional[bool], maximize: Optional[bool], message_peek: Optional[bool], meta: Optional[Dict[str, Any]], name: Optional[str], origin: Optional[str], placeholder: Optional[str], plugins: Optional[str], powered_by: Optional[bool], restart_conversation: Optional[bool], session_duration: Optional[float], start_first: Optional[bool], stream: Optional[bool], theme: Optional[str], title: Optional[str], tools: Optional[bool], unfurl: Optional[bool], updated_at: float, verbose: Optional[bool], voice_in: Optional[bool], voice_out: Optional[bool]) -> None:
+        self.alias = alias
+        self.attachments = attachments
+        self.auto_scroll = auto_scroll
+        self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
+        self.carousel = carousel
+        self.contact_collection = contact_collection
+        self.created_at = created_at
+        self.description = description
+        self.export_conversation = export_conversation
+        self.form = form
+        self.id = id
+        self.initial = initial
+        self.intro = intro
+        self.language = language
+        self.layout = layout
+        self.math = math
+        self.maximize = maximize
+        self.message_peek = message_peek
+        self.meta = meta
+        self.name = name
+        self.origin = origin
+        self.placeholder = placeholder
+        self.plugins = plugins
+        self.powered_by = powered_by
+        self.restart_conversation = restart_conversation
+        self.session_duration = session_duration
+        self.start_first = start_first
+        self.stream = stream
+        self.theme = theme
+        self.title = title
+        self.tools = tools
+        self.unfurl = unfurl
+        self.updated_at = updated_at
+        self.verbose = verbose
+        self.voice_in = voice_in
+        self.voice_out = voice_out
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetListStreamItemData':
+        assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        attachments = from_union([from_bool, from_none], obj.get("attachments"))
+        auto_scroll = from_union([from_bool, from_none], obj.get("autoScroll"))
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        carousel = from_union([from_bool, from_none], obj.get("carousel"))
+        contact_collection = from_union([from_bool, from_none], obj.get("contactCollection"))
+        created_at = from_float(obj.get("createdAt"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        export_conversation = from_union([from_bool, from_none], obj.get("exportConversation"))
+        form = from_union([from_bool, from_none], obj.get("form"))
+        id = from_str(obj.get("id"))
+        initial = from_union([from_str, from_none], obj.get("initial"))
+        intro = from_union([from_str, from_none], obj.get("intro"))
+        language = from_union([from_str, from_none], obj.get("language"))
+        layout = from_union([from_str, from_none], obj.get("layout"))
+        math = from_union([from_bool, from_none], obj.get("math"))
+        maximize = from_union([from_bool, from_none], obj.get("maximize"))
+        message_peek = from_union([from_bool, from_none], obj.get("messagePeek"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        origin = from_union([from_str, from_none], obj.get("origin"))
+        placeholder = from_union([from_str, from_none], obj.get("placeholder"))
+        plugins = from_union([from_str, from_none], obj.get("plugins"))
+        powered_by = from_union([from_bool, from_none], obj.get("poweredBy"))
+        restart_conversation = from_union([from_bool, from_none], obj.get("restartConversation"))
+        session_duration = from_union([from_float, from_none], obj.get("sessionDuration"))
+        start_first = from_union([from_bool, from_none], obj.get("startFirst"))
+        stream = from_union([from_bool, from_none], obj.get("stream"))
+        theme = from_union([from_str, from_none], obj.get("theme"))
+        title = from_union([from_str, from_none], obj.get("title"))
+        tools = from_union([from_bool, from_none], obj.get("tools"))
+        unfurl = from_union([from_bool, from_none], obj.get("unfurl"))
+        updated_at = from_float(obj.get("updatedAt"))
+        verbose = from_union([from_bool, from_none], obj.get("verbose"))
+        voice_in = from_union([from_bool, from_none], obj.get("voiceIn"))
+        voice_out = from_union([from_bool, from_none], obj.get("voiceOut"))
+        return IntegrationWidgetListStreamItemData(alias, attachments, auto_scroll, blueprint_id, bot_id, carousel, contact_collection, created_at, description, export_conversation, form, id, initial, intro, language, layout, math, maximize, message_peek, meta, name, origin, placeholder, plugins, powered_by, restart_conversation, session_duration, start_first, stream, theme, title, tools, unfurl, updated_at, verbose, voice_in, voice_out)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.attachments is not None:
+            result["attachments"] = from_union([from_bool, from_none], self.attachments)
+        if self.auto_scroll is not None:
+            result["autoScroll"] = from_union([from_bool, from_none], self.auto_scroll)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.carousel is not None:
+            result["carousel"] = from_union([from_bool, from_none], self.carousel)
+        if self.contact_collection is not None:
+            result["contactCollection"] = from_union([from_bool, from_none], self.contact_collection)
+        result["createdAt"] = to_float(self.created_at)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        if self.export_conversation is not None:
+            result["exportConversation"] = from_union([from_bool, from_none], self.export_conversation)
+        if self.form is not None:
+            result["form"] = from_union([from_bool, from_none], self.form)
+        result["id"] = from_str(self.id)
+        if self.initial is not None:
+            result["initial"] = from_union([from_str, from_none], self.initial)
+        if self.intro is not None:
+            result["intro"] = from_union([from_str, from_none], self.intro)
+        if self.language is not None:
+            result["language"] = from_union([from_str, from_none], self.language)
+        if self.layout is not None:
+            result["layout"] = from_union([from_str, from_none], self.layout)
+        if self.math is not None:
+            result["math"] = from_union([from_bool, from_none], self.math)
+        if self.maximize is not None:
+            result["maximize"] = from_union([from_bool, from_none], self.maximize)
+        if self.message_peek is not None:
+            result["messagePeek"] = from_union([from_bool, from_none], self.message_peek)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.origin is not None:
+            result["origin"] = from_union([from_str, from_none], self.origin)
+        if self.placeholder is not None:
+            result["placeholder"] = from_union([from_str, from_none], self.placeholder)
+        if self.plugins is not None:
+            result["plugins"] = from_union([from_str, from_none], self.plugins)
+        if self.powered_by is not None:
+            result["poweredBy"] = from_union([from_bool, from_none], self.powered_by)
+        if self.restart_conversation is not None:
+            result["restartConversation"] = from_union([from_bool, from_none], self.restart_conversation)
+        if self.session_duration is not None:
+            result["sessionDuration"] = from_union([to_float, from_none], self.session_duration)
+        if self.start_first is not None:
+            result["startFirst"] = from_union([from_bool, from_none], self.start_first)
+        if self.stream is not None:
+            result["stream"] = from_union([from_bool, from_none], self.stream)
+        if self.theme is not None:
+            result["theme"] = from_union([from_str, from_none], self.theme)
+        if self.title is not None:
+            result["title"] = from_union([from_str, from_none], self.title)
+        if self.tools is not None:
+            result["tools"] = from_union([from_bool, from_none], self.tools)
+        if self.unfurl is not None:
+            result["unfurl"] = from_union([from_bool, from_none], self.unfurl)
+        result["updatedAt"] = to_float(self.updated_at)
+        if self.verbose is not None:
+            result["verbose"] = from_union([from_bool, from_none], self.verbose)
+        if self.voice_in is not None:
+            result["voiceIn"] = from_union([from_bool, from_none], self.voice_in)
+        if self.voice_out is not None:
+            result["voiceOut"] = from_union([from_bool, from_none], self.voice_out)
+        return result
+
+
+class IntegrationWidgetListStreamItemType(Enum):
+    """The type of event"""
+
+    ITEM = "item"
+
+
+class IntegrationWidgetListStreamItem:
+    data: IntegrationWidgetListStreamItemData
+    """A bot configuration that can be applied without a dedicated bot instance."""
+
+    type: IntegrationWidgetListStreamItemType
+    """The type of event"""
+
+    def __init__(self, data: IntegrationWidgetListStreamItemData, type: IntegrationWidgetListStreamItemType) -> None:
+        self.data = data
+        self.type = type
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'IntegrationWidgetListStreamItem':
+        assert isinstance(obj, dict)
+        data = IntegrationWidgetListStreamItemData.from_dict(obj.get("data"))
+        type = IntegrationWidgetListStreamItemType(obj.get("type"))
+        return IntegrationWidgetListStreamItem(data, type)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["data"] = to_class(IntegrationWidgetListStreamItemData, self.data)
+        result["type"] = to_enum(IntegrationWidgetListStreamItemType, self.type)
+        return result
+
+
+class MagicFromPromptGenerateParams:
+    prompt_id: str
+    """The ID of the prompt to use for generation"""
+
+    def __init__(self, prompt_id: str) -> None:
+        self.prompt_id = prompt_id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'MagicFromPromptGenerateParams':
+        assert isinstance(obj, dict)
+        prompt_id = from_str(obj.get("promptId"))
+        return MagicFromPromptGenerateParams(prompt_id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["promptId"] = from_str(self.prompt_id)
+        return result
+
+
+class MagicFromPromptGenerateRequest:
+    model: Optional[str]
+    """Optional language model to use for generation"""
+
+    props: Optional[Dict[str, Any]]
+    """Additional properties to pass to the prompt"""
+
+    text: str
+    """The text to use as input"""
+
+    def __init__(self, model: Optional[str], props: Optional[Dict[str, Any]], text: str) -> None:
+        self.model = model
+        self.props = props
+        self.text = text
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'MagicFromPromptGenerateRequest':
+        assert isinstance(obj, dict)
+        model = from_union([from_str, from_none], obj.get("model"))
+        props = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("props"))
+        text = from_str(obj.get("text"))
+        return MagicFromPromptGenerateRequest(model, props, text)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.model is not None:
+            result["model"] = from_union([from_str, from_none], self.model)
+        if self.props is not None:
+            result["props"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.props)
+        result["text"] = from_str(self.text)
+        return result
+
+
+class MagicFromPromptGenerateResponseUsage:
+    """Usage information"""
+
+    token: float
+    """The tokens used in this exchange"""
+
+    def __init__(self, token: float) -> None:
+        self.token = token
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'MagicFromPromptGenerateResponseUsage':
+        assert isinstance(obj, dict)
+        token = from_float(obj.get("token"))
+        return MagicFromPromptGenerateResponseUsage(token)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["token"] = to_float(self.token)
+        return result
+
+
+class MagicFromPromptGenerateResponse:
+    text: str
+    """The input text"""
+
+    usage: MagicFromPromptGenerateResponseUsage
+    """Usage information"""
+
+    def __init__(self, text: str, usage: MagicFromPromptGenerateResponseUsage) -> None:
+        self.text = text
+        self.usage = usage
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'MagicFromPromptGenerateResponse':
+        assert isinstance(obj, dict)
+        text = from_str(obj.get("text"))
+        usage = MagicFromPromptGenerateResponseUsage.from_dict(obj.get("usage"))
+        return MagicFromPromptGenerateResponse(text, usage)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["text"] = from_str(self.text)
+        result["usage"] = to_class(MagicFromPromptGenerateResponseUsage, self.usage)
+        return result
+
+
+class StickyUsage:
+    """Usage information"""
+
+    token: float
+    """The tokens used in this exchange"""
+
+    def __init__(self, token: float) -> None:
+        self.token = token
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'StickyUsage':
+        assert isinstance(obj, dict)
+        token = from_float(obj.get("token"))
+        return StickyUsage(token)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["token"] = to_float(self.token)
+        return result
+
+
+class MagicFromPromptGenerateStreamItemData:
+    text: str
+    """The input text"""
+
+    usage: StickyUsage
+    """Usage information"""
+
+    def __init__(self, text: str, usage: StickyUsage) -> None:
+        self.text = text
+        self.usage = usage
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'MagicFromPromptGenerateStreamItemData':
+        assert isinstance(obj, dict)
+        text = from_str(obj.get("text"))
+        usage = StickyUsage.from_dict(obj.get("usage"))
+        return MagicFromPromptGenerateStreamItemData(text, usage)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["text"] = from_str(self.text)
+        result["usage"] = to_class(StickyUsage, self.usage)
+        return result
+
+
+class MagicFromPromptGenerateStreamItemType(Enum):
+    """The generated text"""
+
+    RESULT = "result"
+
+
+class MagicFromPromptGenerateStreamItem:
+    data: MagicFromPromptGenerateStreamItemData
+    type: MagicFromPromptGenerateStreamItemType
+    """The generated text"""
+
+    def __init__(self, data: MagicFromPromptGenerateStreamItemData, type: MagicFromPromptGenerateStreamItemType) -> None:
+        self.data = data
+        self.type = type
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'MagicFromPromptGenerateStreamItem':
+        assert isinstance(obj, dict)
+        data = MagicFromPromptGenerateStreamItemData.from_dict(obj.get("data"))
+        type = MagicFromPromptGenerateStreamItemType(obj.get("type"))
+        return MagicFromPromptGenerateStreamItem(data, type)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["data"] = to_class(MagicFromPromptGenerateStreamItemData, self.data)
+        result["type"] = to_enum(MagicFromPromptGenerateStreamItemType, self.type)
         return result
 
 
@@ -35465,6 +36844,9 @@ def to_dict(self) -> dict:
 class PartnerUserUpdateRequest:
     """Instance crud properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     description: Optional[str]
     """The associated description"""
 
@@ -35483,7 +36865,8 @@ class PartnerUserUpdateRequest:
     name: Optional[str]
     """The associated name"""
 
-    def __init__(self, description: Optional[str], email: Optional[str], image: Optional[str], limits: Optional[PartnerUserUpdateRequestLimits], meta: Optional[Dict[str, Any]], name: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], description: Optional[str], email: Optional[str], image: Optional[str], limits: Optional[PartnerUserUpdateRequestLimits], meta: Optional[Dict[str, Any]], name: Optional[str]) -> None:
+        self.alias = alias
         self.description = description
         self.email = email
         self.image = image
@@ -35494,16 +36877,19 @@ def __init__(self, description: Optional[str], email: Optional[str], image: Opti
     @staticmethod
     def from_dict(obj: Any) -> 'PartnerUserUpdateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         description = from_union([from_str, from_none], obj.get("description"))
         email = from_union([from_str, from_none], obj.get("email"))
         image = from_union([from_str, from_none], obj.get("image"))
         limits = from_union([PartnerUserUpdateRequestLimits.from_dict, from_none], obj.get("limits"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        return PartnerUserUpdateRequest(description, email, image, limits, meta, name)
+        return PartnerUserUpdateRequest(alias, description, email, image, limits, meta, name)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         if self.email is not None:
@@ -35634,6 +37020,9 @@ def to_dict(self) -> dict:
 class PartnerUserCreateRequest:
     """Instance crud properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     description: Optional[str]
     """The associated description"""
 
@@ -35652,7 +37041,8 @@ class PartnerUserCreateRequest:
     name: Optional[str]
     """The associated name"""
 
-    def __init__(self, description: Optional[str], email: Optional[str], image: Optional[str], limits: Optional[PartnerUserCreateRequestLimits], meta: Optional[Dict[str, Any]], name: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], description: Optional[str], email: Optional[str], image: Optional[str], limits: Optional[PartnerUserCreateRequestLimits], meta: Optional[Dict[str, Any]], name: Optional[str]) -> None:
+        self.alias = alias
         self.description = description
         self.email = email
         self.image = image
@@ -35663,16 +37053,19 @@ def __init__(self, description: Optional[str], email: Optional[str], image: Opti
     @staticmethod
     def from_dict(obj: Any) -> 'PartnerUserCreateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         description = from_union([from_str, from_none], obj.get("description"))
         email = from_union([from_str, from_none], obj.get("email"))
         image = from_union([from_str, from_none], obj.get("image"))
         limits = from_union([PartnerUserCreateRequestLimits.from_dict, from_none], obj.get("limits"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        return PartnerUserCreateRequest(description, email, image, limits, meta, name)
+        return PartnerUserCreateRequest(alias, description, email, image, limits, meta, name)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         if self.email is not None:
@@ -40484,14 +41877,22 @@ class PolicyFetchResponseType(Enum):
     """The policy type"""
 
     RETENTION = "retention"
+    USAGE = "usage"
 
 
 class PolicyFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
+    bot_id: Optional[str]
+    """The ID of the bot this policy applies to. When omitted the policy is global and applies
+    to every bot.
+    """
     config: Optional[Dict[str, Any]]
     """The policy configuration as JSON"""
 
@@ -40516,8 +41917,10 @@ class PolicyFetchResponse:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], type: PolicyFetchResponseType, updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], type: PolicyFetchResponseType, updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
         self.config = config
         self.created_at = created_at
         self.description = description
@@ -40530,7 +41933,9 @@ def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]]
     @staticmethod
     def from_dict(obj: Any) -> 'PolicyFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
         config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -40539,12 +41944,16 @@ def from_dict(obj: Any) -> 'PolicyFetchResponse':
         name = from_union([from_str, from_none], obj.get("name"))
         type = PolicyFetchResponseType(obj.get("type"))
         updated_at = from_float(obj.get("updatedAt"))
-        return PolicyFetchResponse(blueprint_id, config, created_at, description, id, meta, name, type, updated_at)
+        return PolicyFetchResponse(alias, blueprint_id, bot_id, config, created_at, description, id, meta, name, type, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
         if self.config is not None:
             result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
         result["createdAt"] = to_float(self.created_at)
@@ -40583,14 +41992,22 @@ class PolicyUpdateRequestType(Enum):
     """The policy type"""
 
     RETENTION = "retention"
+    USAGE = "usage"
 
 
 class PolicyUpdateRequest:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
+    bot_id: Optional[str]
+    """The ID of the bot this policy applies to. When omitted the policy is global and applies
+    to every bot.
+    """
     config: Optional[Dict[str, Any]]
     """The policy configuration as JSON"""
 
@@ -40606,8 +42023,10 @@ class PolicyUpdateRequest:
     type: Optional[PolicyUpdateRequestType]
     """The policy type"""
 
-    def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], type: Optional[PolicyUpdateRequestType]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], config: Optional[Dict[str, Any]], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], type: Optional[PolicyUpdateRequestType]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
         self.config = config
         self.description = description
         self.meta = meta
@@ -40617,18 +42036,24 @@ def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]]
     @staticmethod
     def from_dict(obj: Any) -> 'PolicyUpdateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
         config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
         description = from_union([from_str, from_none], obj.get("description"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
         type = from_union([PolicyUpdateRequestType, from_none], obj.get("type"))
-        return PolicyUpdateRequest(blueprint_id, config, description, meta, name, type)
+        return PolicyUpdateRequest(alias, blueprint_id, bot_id, config, description, meta, name, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
         if self.config is not None:
             result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
         if self.description is not None:
@@ -40665,14 +42090,22 @@ class PolicyCreateRequestType(Enum):
     """The policy type"""
 
     RETENTION = "retention"
+    USAGE = "usage"
 
 
 class PolicyCreateRequest:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
+    bot_id: Optional[str]
+    """The ID of the bot this policy applies to. When omitted the policy is global and applies
+    to every bot.
+    """
     config: Optional[Dict[str, Any]]
     """The policy configuration as JSON"""
 
@@ -40688,8 +42121,10 @@ class PolicyCreateRequest:
     type: PolicyCreateRequestType
     """The policy type"""
 
-    def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], type: PolicyCreateRequestType) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], config: Optional[Dict[str, Any]], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], type: PolicyCreateRequestType) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
         self.config = config
         self.description = description
         self.meta = meta
@@ -40699,18 +42134,24 @@ def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]]
     @staticmethod
     def from_dict(obj: Any) -> 'PolicyCreateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
         config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
         description = from_union([from_str, from_none], obj.get("description"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
         type = PolicyCreateRequestType(obj.get("type"))
-        return PolicyCreateRequest(blueprint_id, config, description, meta, name, type)
+        return PolicyCreateRequest(alias, blueprint_id, bot_id, config, description, meta, name, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
         if self.config is not None:
             result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
         if self.description is not None:
@@ -40750,6 +42191,9 @@ class PolicyListParamsOrder(Enum):
 
 
 class PolicyListParams:
+    bot_id: Optional[str]
+    """Filter policies that apply to a specific bot"""
+
     cursor: Optional[str]
     """The cursor to use for pagination"""
 
@@ -40762,7 +42206,8 @@ class PolicyListParams:
     take: Optional[int]
     """The number of items to retrieve"""
 
-    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[PolicyListParamsOrder], take: Optional[int]) -> None:
+    def __init__(self, bot_id: Optional[str], cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[PolicyListParamsOrder], take: Optional[int]) -> None:
+        self.bot_id = bot_id
         self.cursor = cursor
         self.meta = meta
         self.order = order
@@ -40771,14 +42216,17 @@ def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order:
     @staticmethod
     def from_dict(obj: Any) -> 'PolicyListParams':
         assert isinstance(obj, dict)
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
         cursor = from_union([from_str, from_none], obj.get("cursor"))
         meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
         order = from_union([PolicyListParamsOrder, from_none], obj.get("order"))
         take = from_union([from_int, from_none], obj.get("take"))
-        return PolicyListParams(cursor, meta, order, take)
+        return PolicyListParams(bot_id, cursor, meta, order, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
         if self.cursor is not None:
             result["cursor"] = from_union([from_str, from_none], self.cursor)
         if self.meta is not None:
@@ -40794,14 +42242,22 @@ class Type17(Enum):
     """The policy type"""
 
     RETENTION = "retention"
+    USAGE = "usage"
 
 
 class PolicyListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
+    bot_id: Optional[str]
+    """The ID of the bot this policy applies to. When omitted the policy is global and applies
+    to every bot.
+    """
     config: Optional[Dict[str, Any]]
     """The policy configuration as JSON"""
 
@@ -40826,8 +42282,10 @@ class PolicyListResponseItem:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], type: Type17, updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], type: Type17, updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
         self.config = config
         self.created_at = created_at
         self.description = description
@@ -40840,7 +42298,9 @@ def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]]
     @staticmethod
     def from_dict(obj: Any) -> 'PolicyListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
         config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -40849,12 +42309,16 @@ def from_dict(obj: Any) -> 'PolicyListResponseItem':
         name = from_union([from_str, from_none], obj.get("name"))
         type = Type17(obj.get("type"))
         updated_at = from_float(obj.get("updatedAt"))
-        return PolicyListResponseItem(blueprint_id, config, created_at, description, id, meta, name, type, updated_at)
+        return PolicyListResponseItem(alias, blueprint_id, bot_id, config, created_at, description, id, meta, name, type, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
         if self.config is not None:
             result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
         result["createdAt"] = to_float(self.created_at)
@@ -40898,14 +42362,22 @@ class Type18(Enum):
     """The policy type"""
 
     RETENTION = "retention"
+    USAGE = "usage"
 
 
 class PolicyListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
+    bot_id: Optional[str]
+    """The ID of the bot this policy applies to. When omitted the policy is global and applies
+    to every bot.
+    """
     config: Optional[Dict[str, Any]]
     """The policy configuration as JSON"""
 
@@ -40930,8 +42402,10 @@ class PolicyListStreamItemData:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], type: Type18, updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], bot_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], type: Type18, updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
         self.config = config
         self.created_at = created_at
         self.description = description
@@ -40944,7 +42418,9 @@ def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]]
     @staticmethod
     def from_dict(obj: Any) -> 'PolicyListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
         config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
@@ -40953,12 +42429,16 @@ def from_dict(obj: Any) -> 'PolicyListStreamItemData':
         name = from_union([from_str, from_none], obj.get("name"))
         type = Type18(obj.get("type"))
         updated_at = from_float(obj.get("updatedAt"))
-        return PolicyListStreamItemData(blueprint_id, config, created_at, description, id, meta, name, type, updated_at)
+        return PolicyListStreamItemData(alias, blueprint_id, bot_id, config, created_at, description, id, meta, name, type, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
         if self.config is not None:
             result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
         result["createdAt"] = to_float(self.created_at)
@@ -41065,6 +42545,9 @@ def to_dict(self) -> dict:
 class PortalFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -41092,7 +42575,8 @@ class PortalFetchResponse:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], slug: Optional[str], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], slug: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.config = config
         self.created_at = created_at
@@ -41106,6 +42590,7 @@ def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]]
     @staticmethod
     def from_dict(obj: Any) -> 'PortalFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
         created_at = from_float(obj.get("createdAt"))
@@ -41115,10 +42600,12 @@ def from_dict(obj: Any) -> 'PortalFetchResponse':
         name = from_union([from_str, from_none], obj.get("name"))
         slug = from_union([from_str, from_none], obj.get("slug"))
         updated_at = from_float(obj.get("updatedAt"))
-        return PortalFetchResponse(blueprint_id, config, created_at, description, id, meta, name, slug, updated_at)
+        return PortalFetchResponse(alias, blueprint_id, config, created_at, description, id, meta, name, slug, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.config is not None:
@@ -41219,101 +42706,450 @@ def to_dict(self) -> dict:
         return result
 
 
-class PortalUpdateResponse:
+class PortalUpdateResponse:
+    id: str
+    """The ID of the updated portal"""
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PortalUpdateResponse':
+        assert isinstance(obj, dict)
+        id = from_str(obj.get("id"))
+        return PortalUpdateResponse(id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["id"] = from_str(self.id)
+        return result
+
+
+class PortalCreateRequest:
+    """Blueprint properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    config: Optional[Dict[str, Any]]
+    """The config of the portal"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    slug: Optional[str]
+    """The slug of the portal"""
+
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], config: Optional[Dict[str, Any]], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], slug: Optional[str]) -> None:
+        self.alias = alias
+        self.blueprint_id = blueprint_id
+        self.config = config
+        self.description = description
+        self.meta = meta
+        self.name = name
+        self.slug = slug
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PortalCreateRequest':
+        assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        slug = from_union([from_str, from_none], obj.get("slug"))
+        return PortalCreateRequest(alias, blueprint_id, config, description, meta, name, slug)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.config is not None:
+            result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.slug is not None:
+            result["slug"] = from_union([from_str, from_none], self.slug)
+        return result
+
+
+class PortalCreateResponse:
+    id: str
+    """The ID of the created portal"""
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PortalCreateResponse':
+        assert isinstance(obj, dict)
+        id = from_str(obj.get("id"))
+        return PortalCreateResponse(id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["id"] = from_str(self.id)
+        return result
+
+
+class PortalListParamsOrder(Enum):
+    """The order of the paginated items"""
+
+    ASC = "asc"
+    DESC = "desc"
+
+
+class PortalListParams:
+    cursor: Optional[str]
+    """The cursor to use for pagination"""
+
+    meta: Optional[Dict[str, str]]
+    """Key-value pairs to filter the partner users by metadata"""
+
+    order: Optional[PortalListParamsOrder]
+    """The order of the paginated items"""
+
+    take: Optional[int]
+    """The number of items to retrieve"""
+
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[PortalListParamsOrder], take: Optional[int]) -> None:
+        self.cursor = cursor
+        self.meta = meta
+        self.order = order
+        self.take = take
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PortalListParams':
+        assert isinstance(obj, dict)
+        cursor = from_union([from_str, from_none], obj.get("cursor"))
+        meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
+        order = from_union([PortalListParamsOrder, from_none], obj.get("order"))
+        take = from_union([from_int, from_none], obj.get("take"))
+        return PortalListParams(cursor, meta, order, take)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.cursor is not None:
+            result["cursor"] = from_union([from_str, from_none], self.cursor)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
+        if self.order is not None:
+            result["order"] = from_union([lambda x: to_enum(PortalListParamsOrder, x), from_none], self.order)
+        if self.take is not None:
+            result["take"] = from_union([from_int, from_none], self.take)
+        return result
+
+
+class PortalListResponseItem:
+    """Blueprint properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    config: Optional[Dict[str, Any]]
+    """The config of the portal"""
+
+    created_at: float
+    """The timestamp (ms) when the instance was created"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    id: str
+    """The instance ID"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    slug: Optional[str]
+    """The slug of the portal"""
+
+    updated_at: float
+    """The timestamp (ms) when the instance was updated"""
+
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], slug: Optional[str], updated_at: float) -> None:
+        self.alias = alias
+        self.blueprint_id = blueprint_id
+        self.config = config
+        self.created_at = created_at
+        self.description = description
+        self.id = id
+        self.meta = meta
+        self.name = name
+        self.slug = slug
+        self.updated_at = updated_at
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PortalListResponseItem':
+        assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
+        created_at = from_float(obj.get("createdAt"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        id = from_str(obj.get("id"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        slug = from_union([from_str, from_none], obj.get("slug"))
+        updated_at = from_float(obj.get("updatedAt"))
+        return PortalListResponseItem(alias, blueprint_id, config, created_at, description, id, meta, name, slug, updated_at)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.config is not None:
+            result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
+        result["createdAt"] = to_float(self.created_at)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        result["id"] = from_str(self.id)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.slug is not None:
+            result["slug"] = from_union([from_str, from_none], self.slug)
+        result["updatedAt"] = to_float(self.updated_at)
+        return result
+
+
+class PortalListResponse:
+    cursor: str
+    """Cursor for fetching the next page"""
+
+    items: List[PortalListResponseItem]
+
+    def __init__(self, cursor: str, items: List[PortalListResponseItem]) -> None:
+        self.cursor = cursor
+        self.items = items
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PortalListResponse':
+        assert isinstance(obj, dict)
+        cursor = from_str(obj.get("cursor"))
+        items = from_list(PortalListResponseItem.from_dict, obj.get("items"))
+        return PortalListResponse(cursor, items)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["cursor"] = from_str(self.cursor)
+        result["items"] = from_list(lambda x: to_class(PortalListResponseItem, x), self.items)
+        return result
+
+
+class PortalListStreamItemData:
+    """Blueprint properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    config: Optional[Dict[str, Any]]
+    """The config of the portal"""
+
+    created_at: float
+    """The timestamp (ms) when the instance was created"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    id: str
+    """The instance ID"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    slug: Optional[str]
+    """The slug of the portal"""
+
+    updated_at: float
+    """The timestamp (ms) when the instance was updated"""
+
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], slug: Optional[str], updated_at: float) -> None:
+        self.alias = alias
+        self.blueprint_id = blueprint_id
+        self.config = config
+        self.created_at = created_at
+        self.description = description
+        self.id = id
+        self.meta = meta
+        self.name = name
+        self.slug = slug
+        self.updated_at = updated_at
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PortalListStreamItemData':
+        assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
+        created_at = from_float(obj.get("createdAt"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        id = from_str(obj.get("id"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        slug = from_union([from_str, from_none], obj.get("slug"))
+        updated_at = from_float(obj.get("updatedAt"))
+        return PortalListStreamItemData(alias, blueprint_id, config, created_at, description, id, meta, name, slug, updated_at)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.config is not None:
+            result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
+        result["createdAt"] = to_float(self.created_at)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        result["id"] = from_str(self.id)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.slug is not None:
+            result["slug"] = from_union([from_str, from_none], self.slug)
+        result["updatedAt"] = to_float(self.updated_at)
+        return result
+
+
+class PortalListStreamItemType(Enum):
+    """The type of event"""
+
+    ITEM = "item"
+
+
+class PortalListStreamItem:
+    data: PortalListStreamItemData
+    """Blueprint properties"""
+
+    type: PortalListStreamItemType
+    """The type of event"""
+
+    def __init__(self, data: PortalListStreamItemData, type: PortalListStreamItemType) -> None:
+        self.data = data
+        self.type = type
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'PortalListStreamItem':
+        assert isinstance(obj, dict)
+        data = PortalListStreamItemData.from_dict(obj.get("data"))
+        type = PortalListStreamItemType(obj.get("type"))
+        return PortalListStreamItem(data, type)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["data"] = to_class(PortalListStreamItemData, self.data)
+        result["type"] = to_enum(PortalListStreamItemType, self.type)
+        return result
+
+
+class SecretAuthenticateParams:
+    secret_id: str
+    """The ID of the secret to authenticate"""
+
+    def __init__(self, secret_id: str) -> None:
+        self.secret_id = secret_id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SecretAuthenticateParams':
+        assert isinstance(obj, dict)
+        secret_id = from_str(obj.get("secretId"))
+        return SecretAuthenticateParams(secret_id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["secretId"] = from_str(self.secret_id)
+        return result
+
+
+class SecretAuthenticateResponse:
     id: str
-    """The ID of the updated portal"""
+    """The ID of the secret to authenticate"""
 
-    def __init__(self, id: str) -> None:
+    url: str
+    """The URL to authenticate the secret"""
+
+    def __init__(self, id: str, url: str) -> None:
         self.id = id
+        self.url = url
 
     @staticmethod
-    def from_dict(obj: Any) -> 'PortalUpdateResponse':
+    def from_dict(obj: Any) -> 'SecretAuthenticateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return PortalUpdateResponse(id)
+        url = from_str(obj.get("url"))
+        return SecretAuthenticateResponse(id, url)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["id"] = from_str(self.id)
+        result["url"] = from_str(self.url)
         return result
 
 
-class PortalCreateRequest:
-    """Blueprint properties"""
-
-    alias: Optional[str]
-    """The unique alias for the instance"""
-
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
-
-    config: Optional[Dict[str, Any]]
-    """The config of the portal"""
-
-    description: Optional[str]
-    """The associated description"""
-
-    meta: Optional[Dict[str, Any]]
-    """Meta data information"""
-
-    name: Optional[str]
-    """The associated name"""
-
-    slug: Optional[str]
-    """The slug of the portal"""
+class SecretDeleteParams:
+    secret_id: str
+    """The ID of the secret to delete"""
 
-    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], config: Optional[Dict[str, Any]], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], slug: Optional[str]) -> None:
-        self.alias = alias
-        self.blueprint_id = blueprint_id
-        self.config = config
-        self.description = description
-        self.meta = meta
-        self.name = name
-        self.slug = slug
+    def __init__(self, secret_id: str) -> None:
+        self.secret_id = secret_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'PortalCreateRequest':
+    def from_dict(obj: Any) -> 'SecretDeleteParams':
         assert isinstance(obj, dict)
-        alias = from_union([from_str, from_none], obj.get("alias"))
-        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
-        description = from_union([from_str, from_none], obj.get("description"))
-        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        name = from_union([from_str, from_none], obj.get("name"))
-        slug = from_union([from_str, from_none], obj.get("slug"))
-        return PortalCreateRequest(alias, blueprint_id, config, description, meta, name, slug)
+        secret_id = from_str(obj.get("secretId"))
+        return SecretDeleteParams(secret_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.alias is not None:
-            result["alias"] = from_union([from_str, from_none], self.alias)
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.config is not None:
-            result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
-        if self.description is not None:
-            result["description"] = from_union([from_str, from_none], self.description)
-        if self.meta is not None:
-            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        if self.name is not None:
-            result["name"] = from_union([from_str, from_none], self.name)
-        if self.slug is not None:
-            result["slug"] = from_union([from_str, from_none], self.slug)
+        result["secretId"] = from_str(self.secret_id)
         return result
 
 
-class PortalCreateResponse:
+class SecretDeleteResponse:
     id: str
-    """The ID of the created portal"""
+    """The ID of the deleted secret"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'PortalCreateResponse':
+    def from_dict(obj: Any) -> 'SecretDeleteResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return PortalCreateResponse(id)
+        return SecretDeleteResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -41321,62 +43157,63 @@ def to_dict(self) -> dict:
         return result
 
 
-class PortalListParamsOrder(Enum):
-    """The order of the paginated items"""
+class SecretFetchParams:
+    secret_id: str
+    """The ID of the secret to retrieve"""
 
-    ASC = "asc"
-    DESC = "desc"
+    def __init__(self, secret_id: str) -> None:
+        self.secret_id = secret_id
 
+    @staticmethod
+    def from_dict(obj: Any) -> 'SecretFetchParams':
+        assert isinstance(obj, dict)
+        secret_id = from_str(obj.get("secretId"))
+        return SecretFetchParams(secret_id)
 
-class PortalListParams:
-    cursor: Optional[str]
-    """The cursor to use for pagination"""
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["secretId"] = from_str(self.secret_id)
+        return result
 
-    meta: Optional[Dict[str, str]]
-    """Key-value pairs to filter the partner users by metadata"""
 
-    order: Optional[PortalListParamsOrder]
-    """The order of the paginated items"""
+class SecretFetchResponseKind(Enum):
+    """The kind of the secret"""
 
-    take: Optional[int]
-    """The number of items to retrieve"""
+    PERSONAL = "personal"
+    SHARED = "shared"
 
-    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[PortalListParamsOrder], take: Optional[int]) -> None:
-        self.cursor = cursor
-        self.meta = meta
-        self.order = order
-        self.take = take
 
-    @staticmethod
-    def from_dict(obj: Any) -> 'PortalListParams':
-        assert isinstance(obj, dict)
-        cursor = from_union([from_str, from_none], obj.get("cursor"))
-        meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
-        order = from_union([PortalListParamsOrder, from_none], obj.get("order"))
-        take = from_union([from_int, from_none], obj.get("take"))
-        return PortalListParams(cursor, meta, order, take)
+class SecretFetchResponseType(Enum):
+    """The type of the secret"""
 
-    def to_dict(self) -> dict:
-        result: dict = {}
-        if self.cursor is not None:
-            result["cursor"] = from_union([from_str, from_none], self.cursor)
-        if self.meta is not None:
-            result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
-        if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(PortalListParamsOrder, x), from_none], self.order)
-        if self.take is not None:
-            result["take"] = from_union([from_int, from_none], self.take)
-        return result
+    BASIC = "basic"
+    BEARER = "bearer"
+    JWT = "jwt"
+    OAUTH = "oauth"
+    PLAIN = "plain"
+    REFERENCE = "reference"
+    TEMPLATE = "template"
 
 
-class PortalListResponseItem:
+class SecretFetchResponseVisibility(Enum):
+    """The visibility of the secret"""
+
+    PRIVATE = "private"
+    PROTECTED = "protected"
+    PUBLIC = "public"
+
+
+class SecretFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
     config: Optional[Dict[str, Any]]
-    """The config of the portal"""
+    """The config of the secret"""
 
     created_at: float
     """The timestamp (ms) when the instance was created"""
@@ -41387,45 +43224,59 @@ class PortalListResponseItem:
     id: str
     """The instance ID"""
 
+    kind: Optional[SecretFetchResponseKind]
+    """The kind of the secret"""
+
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    slug: Optional[str]
-    """The slug of the portal"""
+    type: Optional[SecretFetchResponseType]
+    """The type of the secret"""
 
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], slug: Optional[str], updated_at: float) -> None:
+    visibility: Optional[SecretFetchResponseVisibility]
+    """The visibility of the secret"""
+
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, kind: Optional[SecretFetchResponseKind], meta: Optional[Dict[str, Any]], name: Optional[str], type: Optional[SecretFetchResponseType], updated_at: float, visibility: Optional[SecretFetchResponseVisibility]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.config = config
         self.created_at = created_at
         self.description = description
         self.id = id
+        self.kind = kind
         self.meta = meta
         self.name = name
-        self.slug = slug
+        self.type = type
         self.updated_at = updated_at
+        self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'PortalListResponseItem':
+    def from_dict(obj: Any) -> 'SecretFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
+        kind = from_union([SecretFetchResponseKind, from_none], obj.get("kind"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        slug = from_union([from_str, from_none], obj.get("slug"))
+        type = from_union([SecretFetchResponseType, from_none], obj.get("type"))
         updated_at = from_float(obj.get("updatedAt"))
-        return PortalListResponseItem(blueprint_id, config, created_at, description, id, meta, name, slug, updated_at)
+        visibility = from_union([SecretFetchResponseVisibility, from_none], obj.get("visibility"))
+        return SecretFetchResponse(alias, blueprint_id, config, created_at, description, id, kind, meta, name, type, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.config is not None:
@@ -41434,57 +43285,119 @@ def to_dict(self) -> dict:
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
         result["id"] = from_str(self.id)
+        if self.kind is not None:
+            result["kind"] = from_union([lambda x: to_enum(SecretFetchResponseKind, x), from_none], self.kind)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.slug is not None:
-            result["slug"] = from_union([from_str, from_none], self.slug)
+        if self.type is not None:
+            result["type"] = from_union([lambda x: to_enum(SecretFetchResponseType, x), from_none], self.type)
         result["updatedAt"] = to_float(self.updated_at)
+        if self.visibility is not None:
+            result["visibility"] = from_union([lambda x: to_enum(SecretFetchResponseVisibility, x), from_none], self.visibility)
         return result
 
 
-class PortalListResponse:
-    cursor: str
-    """Cursor for fetching the next page"""
+class SecretRevokeParams:
+    secret_id: str
 
-    items: List[PortalListResponseItem]
+    def __init__(self, secret_id: str) -> None:
+        self.secret_id = secret_id
 
-    def __init__(self, cursor: str, items: List[PortalListResponseItem]) -> None:
-        self.cursor = cursor
-        self.items = items
+    @staticmethod
+    def from_dict(obj: Any) -> 'SecretRevokeParams':
+        assert isinstance(obj, dict)
+        secret_id = from_str(obj.get("secretId"))
+        return SecretRevokeParams(secret_id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["secretId"] = from_str(self.secret_id)
+        return result
+
+
+class SecretRevokeResponse:
+    id: str
+    """The ID of the revoked secret"""
+
+    def __init__(self, id: str) -> None:
+        self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'PortalListResponse':
+    def from_dict(obj: Any) -> 'SecretRevokeResponse':
         assert isinstance(obj, dict)
-        cursor = from_str(obj.get("cursor"))
-        items = from_list(PortalListResponseItem.from_dict, obj.get("items"))
-        return PortalListResponse(cursor, items)
+        id = from_str(obj.get("id"))
+        return SecretRevokeResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["cursor"] = from_str(self.cursor)
-        result["items"] = from_list(lambda x: to_class(PortalListResponseItem, x), self.items)
+        result["id"] = from_str(self.id)
         return result
 
 
-class PortalListStreamItemData:
+class SecretUpdateParams:
+    secret_id: str
+
+    def __init__(self, secret_id: str) -> None:
+        self.secret_id = secret_id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SecretUpdateParams':
+        assert isinstance(obj, dict)
+        secret_id = from_str(obj.get("secretId"))
+        return SecretUpdateParams(secret_id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["secretId"] = from_str(self.secret_id)
+        return result
+
+
+class SecretUpdateRequestKind(Enum):
+    """The kind of the secret"""
+
+    PERSONAL = "personal"
+    SHARED = "shared"
+
+
+class SecretUpdateRequestType(Enum):
+    """The type of the secret"""
+
+    BASIC = "basic"
+    BEARER = "bearer"
+    JWT = "jwt"
+    OAUTH = "oauth"
+    PLAIN = "plain"
+    REFERENCE = "reference"
+    TEMPLATE = "template"
+
+
+class SecretUpdateRequestVisibility(Enum):
+    """The visibility of the secret"""
+
+    PRIVATE = "private"
+    PROTECTED = "protected"
+    PUBLIC = "public"
+
+
+class SecretUpdateRequest:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
     config: Optional[Dict[str, Any]]
-    """The config of the portal"""
-
-    created_at: float
-    """The timestamp (ms) when the instance was created"""
+    """The config of the secret"""
 
     description: Optional[str]
     """The associated description"""
 
-    id: str
-    """The instance ID"""
+    kind: Optional[SecretUpdateRequestKind]
+    """The kind of the secret"""
 
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
@@ -41492,100 +43405,98 @@ class PortalListStreamItemData:
     name: Optional[str]
     """The associated name"""
 
-    slug: Optional[str]
-    """The slug of the portal"""
+    type: Optional[SecretUpdateRequestType]
+    """The type of the secret"""
 
-    updated_at: float
-    """The timestamp (ms) when the instance was updated"""
+    value: Optional[str]
+    """The value of the secret"""
 
-    def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], slug: Optional[str], updated_at: float) -> None:
+    visibility: Optional[SecretUpdateRequestVisibility]
+    """The visibility of the secret"""
+
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], config: Optional[Dict[str, Any]], description: Optional[str], kind: Optional[SecretUpdateRequestKind], meta: Optional[Dict[str, Any]], name: Optional[str], type: Optional[SecretUpdateRequestType], value: Optional[str], visibility: Optional[SecretUpdateRequestVisibility]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.config = config
-        self.created_at = created_at
         self.description = description
-        self.id = id
+        self.kind = kind
         self.meta = meta
         self.name = name
-        self.slug = slug
-        self.updated_at = updated_at
+        self.type = type
+        self.value = value
+        self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'PortalListStreamItemData':
+    def from_dict(obj: Any) -> 'SecretUpdateRequest':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
-        created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
-        id = from_str(obj.get("id"))
+        kind = from_union([SecretUpdateRequestKind, from_none], obj.get("kind"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        slug = from_union([from_str, from_none], obj.get("slug"))
-        updated_at = from_float(obj.get("updatedAt"))
-        return PortalListStreamItemData(blueprint_id, config, created_at, description, id, meta, name, slug, updated_at)
+        type = from_union([SecretUpdateRequestType, from_none], obj.get("type"))
+        value = from_union([from_str, from_none], obj.get("value"))
+        visibility = from_union([SecretUpdateRequestVisibility, from_none], obj.get("visibility"))
+        return SecretUpdateRequest(alias, blueprint_id, config, description, kind, meta, name, type, value, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.config is not None:
             result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
-        result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
-        result["id"] = from_str(self.id)
+        if self.kind is not None:
+            result["kind"] = from_union([lambda x: to_enum(SecretUpdateRequestKind, x), from_none], self.kind)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.slug is not None:
-            result["slug"] = from_union([from_str, from_none], self.slug)
-        result["updatedAt"] = to_float(self.updated_at)
+        if self.type is not None:
+            result["type"] = from_union([lambda x: to_enum(SecretUpdateRequestType, x), from_none], self.type)
+        if self.value is not None:
+            result["value"] = from_union([from_str, from_none], self.value)
+        if self.visibility is not None:
+            result["visibility"] = from_union([lambda x: to_enum(SecretUpdateRequestVisibility, x), from_none], self.visibility)
         return result
 
 
-class PortalListStreamItemType(Enum):
-    """The type of event"""
-
-    ITEM = "item"
-
-
-class PortalListStreamItem:
-    data: PortalListStreamItemData
-    """Blueprint properties"""
-
-    type: PortalListStreamItemType
-    """The type of event"""
+class SecretUpdateResponse:
+    id: str
+    """The ID of the updated secret"""
 
-    def __init__(self, data: PortalListStreamItemData, type: PortalListStreamItemType) -> None:
-        self.data = data
-        self.type = type
+    def __init__(self, id: str) -> None:
+        self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'PortalListStreamItem':
+    def from_dict(obj: Any) -> 'SecretUpdateResponse':
         assert isinstance(obj, dict)
-        data = PortalListStreamItemData.from_dict(obj.get("data"))
-        type = PortalListStreamItemType(obj.get("type"))
-        return PortalListStreamItem(data, type)
+        id = from_str(obj.get("id"))
+        return SecretUpdateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["data"] = to_class(PortalListStreamItemData, self.data)
-        result["type"] = to_enum(PortalListStreamItemType, self.type)
+        result["id"] = from_str(self.id)
         return result
 
 
-class SecretAuthenticateParams:
+class SecretVerifyParams:
     secret_id: str
-    """The ID of the secret to authenticate"""
+    """The ID of the secret to be verified"""
 
     def __init__(self, secret_id: str) -> None:
         self.secret_id = secret_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretAuthenticateParams':
+    def from_dict(obj: Any) -> 'SecretVerifyParams':
         assert isinstance(obj, dict)
         secret_id = from_str(obj.get("secretId"))
-        return SecretAuthenticateParams(secret_id)
+        return SecretVerifyParams(secret_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -41593,62 +43504,200 @@ def to_dict(self) -> dict:
         return result
 
 
-class SecretAuthenticateResponse:
-    id: str
-    """The ID of the secret to authenticate"""
+class Type19(Enum):
+    """The type of action to take"""
+
+    AUTHENTICATE = "authenticate"
+
+
+class SecretVerifyResponseAction:
+    """The action to take next"""
+
+    type: Type19
+    """The type of action to take"""
 
     url: str
     """The URL to authenticate the secret"""
 
-    def __init__(self, id: str, url: str) -> None:
-        self.id = id
+    def __init__(self, type: Type19, url: str) -> None:
+        self.type = type
         self.url = url
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretAuthenticateResponse':
+    def from_dict(obj: Any) -> 'SecretVerifyResponseAction':
         assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
+        type = Type19(obj.get("type"))
         url = from_str(obj.get("url"))
-        return SecretAuthenticateResponse(id, url)
+        return SecretVerifyResponseAction(type, url)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["id"] = from_str(self.id)
+        result["type"] = to_enum(Type19, self.type)
         result["url"] = from_str(self.url)
         return result
 
 
-class SecretDeleteParams:
-    secret_id: str
-    """The ID of the secret to delete"""
+class SecretVerifyResponseStatus(Enum):
+    """The status of the secret"""
 
-    def __init__(self, secret_id: str) -> None:
-        self.secret_id = secret_id
+    AUTHENTICATED = "authenticated"
+    UNAUTHENTICATED = "unauthenticated"
+
+
+class SecretVerifyResponse:
+    action: Optional[SecretVerifyResponseAction]
+    id: str
+    """The ID of the verified secret"""
+
+    status: SecretVerifyResponseStatus
+    """The status of the secret"""
+
+    def __init__(self, action: Optional[SecretVerifyResponseAction], id: str, status: SecretVerifyResponseStatus) -> None:
+        self.action = action
+        self.id = id
+        self.status = status
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SecretVerifyResponse':
+        assert isinstance(obj, dict)
+        action = from_union([SecretVerifyResponseAction.from_dict, from_none], obj.get("action"))
+        id = from_str(obj.get("id"))
+        status = SecretVerifyResponseStatus(obj.get("status"))
+        return SecretVerifyResponse(action, id, status)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.action is not None:
+            result["action"] = from_union([lambda x: to_class(SecretVerifyResponseAction, x), from_none], self.action)
+        result["id"] = from_str(self.id)
+        result["status"] = to_enum(SecretVerifyResponseStatus, self.status)
+        return result
+
+
+class SecretCreateRequestKind(Enum):
+    """The kind of the secret"""
+
+    PERSONAL = "personal"
+    SHARED = "shared"
+
+
+class SecretCreateRequestType(Enum):
+    """The type of the secret"""
+
+    BASIC = "basic"
+    BEARER = "bearer"
+    JWT = "jwt"
+    OAUTH = "oauth"
+    PLAIN = "plain"
+    REFERENCE = "reference"
+    TEMPLATE = "template"
+
+
+class SecretCreateRequestVisibility(Enum):
+    """The visibility of the secret"""
+
+    PRIVATE = "private"
+    PROTECTED = "protected"
+    PUBLIC = "public"
+
+
+class SecretCreateRequest:
+    """Blueprint properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    config: Optional[Dict[str, Any]]
+    """The config of the secret"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    kind: Optional[SecretCreateRequestKind]
+    """The kind of the secret"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    type: Optional[SecretCreateRequestType]
+    """The type of the secret"""
+
+    value: Optional[str]
+    """The value of the secret"""
+
+    visibility: Optional[SecretCreateRequestVisibility]
+    """The visibility of the secret"""
+
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], config: Optional[Dict[str, Any]], description: Optional[str], kind: Optional[SecretCreateRequestKind], meta: Optional[Dict[str, Any]], name: Optional[str], type: Optional[SecretCreateRequestType], value: Optional[str], visibility: Optional[SecretCreateRequestVisibility]) -> None:
+        self.alias = alias
+        self.blueprint_id = blueprint_id
+        self.config = config
+        self.description = description
+        self.kind = kind
+        self.meta = meta
+        self.name = name
+        self.type = type
+        self.value = value
+        self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretDeleteParams':
+    def from_dict(obj: Any) -> 'SecretCreateRequest':
         assert isinstance(obj, dict)
-        secret_id = from_str(obj.get("secretId"))
-        return SecretDeleteParams(secret_id)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        kind = from_union([SecretCreateRequestKind, from_none], obj.get("kind"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        type = from_union([SecretCreateRequestType, from_none], obj.get("type"))
+        value = from_union([from_str, from_none], obj.get("value"))
+        visibility = from_union([SecretCreateRequestVisibility, from_none], obj.get("visibility"))
+        return SecretCreateRequest(alias, blueprint_id, config, description, kind, meta, name, type, value, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["secretId"] = from_str(self.secret_id)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.config is not None:
+            result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        if self.kind is not None:
+            result["kind"] = from_union([lambda x: to_enum(SecretCreateRequestKind, x), from_none], self.kind)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.type is not None:
+            result["type"] = from_union([lambda x: to_enum(SecretCreateRequestType, x), from_none], self.type)
+        if self.value is not None:
+            result["value"] = from_union([from_str, from_none], self.value)
+        if self.visibility is not None:
+            result["visibility"] = from_union([lambda x: to_enum(SecretCreateRequestVisibility, x), from_none], self.visibility)
         return result
 
 
-class SecretDeleteResponse:
+class SecretCreateResponse:
     id: str
-    """The ID of the deleted secret"""
+    """The ID of the created secret"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretDeleteResponse':
+    def from_dict(obj: Any) -> 'SecretCreateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return SecretDeleteResponse(id)
+        return SecretCreateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -41656,33 +43705,62 @@ def to_dict(self) -> dict:
         return result
 
 
-class SecretFetchParams:
-    secret_id: str
-    """The ID of the secret to retrieve"""
+class SecretListParamsOrder(Enum):
+    """The order of the paginated items"""
 
-    def __init__(self, secret_id: str) -> None:
-        self.secret_id = secret_id
+    ASC = "asc"
+    DESC = "desc"
+
+
+class SecretListParams:
+    cursor: Optional[str]
+    """The cursor to use for pagination"""
+
+    meta: Optional[Dict[str, str]]
+    """Key-value pairs to filter the partner users by metadata"""
+
+    order: Optional[SecretListParamsOrder]
+    """The order of the paginated items"""
+
+    take: Optional[int]
+    """The number of items to retrieve"""
+
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[SecretListParamsOrder], take: Optional[int]) -> None:
+        self.cursor = cursor
+        self.meta = meta
+        self.order = order
+        self.take = take
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretFetchParams':
+    def from_dict(obj: Any) -> 'SecretListParams':
         assert isinstance(obj, dict)
-        secret_id = from_str(obj.get("secretId"))
-        return SecretFetchParams(secret_id)
+        cursor = from_union([from_str, from_none], obj.get("cursor"))
+        meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
+        order = from_union([SecretListParamsOrder, from_none], obj.get("order"))
+        take = from_union([from_int, from_none], obj.get("take"))
+        return SecretListParams(cursor, meta, order, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["secretId"] = from_str(self.secret_id)
+        if self.cursor is not None:
+            result["cursor"] = from_union([from_str, from_none], self.cursor)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
+        if self.order is not None:
+            result["order"] = from_union([lambda x: to_enum(SecretListParamsOrder, x), from_none], self.order)
+        if self.take is not None:
+            result["take"] = from_union([from_int, from_none], self.take)
         return result
 
 
-class SecretFetchResponseKind(Enum):
+class IndigoKind(Enum):
     """The kind of the secret"""
 
     PERSONAL = "personal"
     SHARED = "shared"
 
 
-class SecretFetchResponseType(Enum):
+class Type20(Enum):
     """The type of the secret"""
 
     BASIC = "basic"
@@ -41694,7 +43772,7 @@ class SecretFetchResponseType(Enum):
     TEMPLATE = "template"
 
 
-class SecretFetchResponseVisibility(Enum):
+class FriskyVisibility(Enum):
     """The visibility of the secret"""
 
     PRIVATE = "private"
@@ -41702,9 +43780,12 @@ class SecretFetchResponseVisibility(Enum):
     PUBLIC = "public"
 
 
-class SecretFetchResponse:
+class SecretListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -41720,7 +43801,7 @@ class SecretFetchResponse:
     id: str
     """The instance ID"""
 
-    kind: Optional[SecretFetchResponseKind]
+    kind: Optional[IndigoKind]
     """The kind of the secret"""
 
     meta: Optional[Dict[str, Any]]
@@ -41729,16 +43810,17 @@ class SecretFetchResponse:
     name: Optional[str]
     """The associated name"""
 
-    type: Optional[SecretFetchResponseType]
+    type: Optional[Type20]
     """The type of the secret"""
 
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    visibility: Optional[SecretFetchResponseVisibility]
+    visibility: Optional[FriskyVisibility]
     """The visibility of the secret"""
 
-    def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, kind: Optional[SecretFetchResponseKind], meta: Optional[Dict[str, Any]], name: Optional[str], type: Optional[SecretFetchResponseType], updated_at: float, visibility: Optional[SecretFetchResponseVisibility]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, kind: Optional[IndigoKind], meta: Optional[Dict[str, Any]], name: Optional[str], type: Optional[Type20], updated_at: float, visibility: Optional[FriskyVisibility]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.config = config
         self.created_at = created_at
@@ -41752,23 +43834,26 @@ def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]]
         self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretFetchResponse':
+    def from_dict(obj: Any) -> 'SecretListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
-        kind = from_union([SecretFetchResponseKind, from_none], obj.get("kind"))
+        kind = from_union([IndigoKind, from_none], obj.get("kind"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        type = from_union([SecretFetchResponseType, from_none], obj.get("type"))
+        type = from_union([Type20, from_none], obj.get("type"))
         updated_at = from_float(obj.get("updatedAt"))
-        visibility = from_union([SecretFetchResponseVisibility, from_none], obj.get("visibility"))
-        return SecretFetchResponse(blueprint_id, config, created_at, description, id, kind, meta, name, type, updated_at, visibility)
+        visibility = from_union([FriskyVisibility, from_none], obj.get("visibility"))
+        return SecretListResponseItem(alias, blueprint_id, config, created_at, description, id, kind, meta, name, type, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.config is not None:
@@ -41778,82 +43863,51 @@ def to_dict(self) -> dict:
             result["description"] = from_union([from_str, from_none], self.description)
         result["id"] = from_str(self.id)
         if self.kind is not None:
-            result["kind"] = from_union([lambda x: to_enum(SecretFetchResponseKind, x), from_none], self.kind)
+            result["kind"] = from_union([lambda x: to_enum(IndigoKind, x), from_none], self.kind)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
         if self.type is not None:
-            result["type"] = from_union([lambda x: to_enum(SecretFetchResponseType, x), from_none], self.type)
+            result["type"] = from_union([lambda x: to_enum(Type20, x), from_none], self.type)
         result["updatedAt"] = to_float(self.updated_at)
         if self.visibility is not None:
-            result["visibility"] = from_union([lambda x: to_enum(SecretFetchResponseVisibility, x), from_none], self.visibility)
-        return result
-
-
-class SecretRevokeParams:
-    secret_id: str
-
-    def __init__(self, secret_id: str) -> None:
-        self.secret_id = secret_id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'SecretRevokeParams':
-        assert isinstance(obj, dict)
-        secret_id = from_str(obj.get("secretId"))
-        return SecretRevokeParams(secret_id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["secretId"] = from_str(self.secret_id)
+            result["visibility"] = from_union([lambda x: to_enum(FriskyVisibility, x), from_none], self.visibility)
         return result
 
 
-class SecretRevokeResponse:
-    id: str
-    """The ID of the revoked secret"""
-
-    def __init__(self, id: str) -> None:
-        self.id = id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'SecretRevokeResponse':
-        assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
-        return SecretRevokeResponse(id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["id"] = from_str(self.id)
-        return result
-
+class SecretListResponse:
+    cursor: str
+    """Cursor for fetching the next page"""
 
-class SecretUpdateParams:
-    secret_id: str
+    items: List[SecretListResponseItem]
 
-    def __init__(self, secret_id: str) -> None:
-        self.secret_id = secret_id
+    def __init__(self, cursor: str, items: List[SecretListResponseItem]) -> None:
+        self.cursor = cursor
+        self.items = items
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretUpdateParams':
+    def from_dict(obj: Any) -> 'SecretListResponse':
         assert isinstance(obj, dict)
-        secret_id = from_str(obj.get("secretId"))
-        return SecretUpdateParams(secret_id)
+        cursor = from_str(obj.get("cursor"))
+        items = from_list(SecretListResponseItem.from_dict, obj.get("items"))
+        return SecretListResponse(cursor, items)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["secretId"] = from_str(self.secret_id)
+        result["cursor"] = from_str(self.cursor)
+        result["items"] = from_list(lambda x: to_class(SecretListResponseItem, x), self.items)
         return result
 
 
-class SecretUpdateRequestKind(Enum):
+class IndecentKind(Enum):
     """The kind of the secret"""
 
     PERSONAL = "personal"
     SHARED = "shared"
 
 
-class SecretUpdateRequestType(Enum):
+class Type21(Enum):
     """The type of the secret"""
 
     BASIC = "basic"
@@ -41865,7 +43919,7 @@ class SecretUpdateRequestType(Enum):
     TEMPLATE = "template"
 
 
-class SecretUpdateRequestVisibility(Enum):
+class MischievousVisibility(Enum):
     """The visibility of the secret"""
 
     PRIVATE = "private"
@@ -41873,7 +43927,7 @@ class SecretUpdateRequestVisibility(Enum):
     PUBLIC = "public"
 
 
-class SecretUpdateRequest:
+class SecretListStreamItemData:
     """Blueprint properties"""
 
     alias: Optional[str]
@@ -41885,10 +43939,16 @@ class SecretUpdateRequest:
     config: Optional[Dict[str, Any]]
     """The config of the secret"""
 
+    created_at: float
+    """The timestamp (ms) when the instance was created"""
+
     description: Optional[str]
     """The associated description"""
 
-    kind: Optional[SecretUpdateRequestKind]
+    id: str
+    """The instance ID"""
+
+    kind: Optional[IndecentKind]
     """The kind of the secret"""
 
     meta: Optional[Dict[str, Any]]
@@ -41897,41 +43957,45 @@ class SecretUpdateRequest:
     name: Optional[str]
     """The associated name"""
 
-    type: Optional[SecretUpdateRequestType]
+    type: Optional[Type21]
     """The type of the secret"""
 
-    value: Optional[str]
-    """The value of the secret"""
+    updated_at: float
+    """The timestamp (ms) when the instance was updated"""
 
-    visibility: Optional[SecretUpdateRequestVisibility]
+    visibility: Optional[MischievousVisibility]
     """The visibility of the secret"""
 
-    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], config: Optional[Dict[str, Any]], description: Optional[str], kind: Optional[SecretUpdateRequestKind], meta: Optional[Dict[str, Any]], name: Optional[str], type: Optional[SecretUpdateRequestType], value: Optional[str], visibility: Optional[SecretUpdateRequestVisibility]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, kind: Optional[IndecentKind], meta: Optional[Dict[str, Any]], name: Optional[str], type: Optional[Type21], updated_at: float, visibility: Optional[MischievousVisibility]) -> None:
         self.alias = alias
         self.blueprint_id = blueprint_id
         self.config = config
+        self.created_at = created_at
         self.description = description
+        self.id = id
         self.kind = kind
         self.meta = meta
         self.name = name
         self.type = type
-        self.value = value
+        self.updated_at = updated_at
         self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretUpdateRequest':
+    def from_dict(obj: Any) -> 'SecretListStreamItemData':
         assert isinstance(obj, dict)
         alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
+        created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
-        kind = from_union([SecretUpdateRequestKind, from_none], obj.get("kind"))
+        id = from_str(obj.get("id"))
+        kind = from_union([IndecentKind, from_none], obj.get("kind"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        type = from_union([SecretUpdateRequestType, from_none], obj.get("type"))
-        value = from_union([from_str, from_none], obj.get("value"))
-        visibility = from_union([SecretUpdateRequestVisibility, from_none], obj.get("visibility"))
-        return SecretUpdateRequest(alias, blueprint_id, config, description, kind, meta, name, type, value, visibility)
+        type = from_union([Type21, from_none], obj.get("type"))
+        updated_at = from_float(obj.get("updatedAt"))
+        visibility = from_union([MischievousVisibility, from_none], obj.get("visibility"))
+        return SecretListStreamItemData(alias, blueprint_id, config, created_at, description, id, kind, meta, name, type, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -41941,634 +44005,737 @@ def to_dict(self) -> dict:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.config is not None:
             result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
+        result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
+        result["id"] = from_str(self.id)
         if self.kind is not None:
-            result["kind"] = from_union([lambda x: to_enum(SecretUpdateRequestKind, x), from_none], self.kind)
+            result["kind"] = from_union([lambda x: to_enum(IndecentKind, x), from_none], self.kind)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
         if self.type is not None:
-            result["type"] = from_union([lambda x: to_enum(SecretUpdateRequestType, x), from_none], self.type)
-        if self.value is not None:
-            result["value"] = from_union([from_str, from_none], self.value)
+            result["type"] = from_union([lambda x: to_enum(Type21, x), from_none], self.type)
+        result["updatedAt"] = to_float(self.updated_at)
         if self.visibility is not None:
-            result["visibility"] = from_union([lambda x: to_enum(SecretUpdateRequestVisibility, x), from_none], self.visibility)
+            result["visibility"] = from_union([lambda x: to_enum(MischievousVisibility, x), from_none], self.visibility)
         return result
 
 
-class SecretUpdateResponse:
-    id: str
-    """The ID of the updated secret"""
-
-    def __init__(self, id: str) -> None:
-        self.id = id
+class SecretListStreamItemType(Enum):
+    """The type of event"""
 
-    @staticmethod
-    def from_dict(obj: Any) -> 'SecretUpdateResponse':
-        assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
-        return SecretUpdateResponse(id)
+    ITEM = "item"
 
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["id"] = from_str(self.id)
-        return result
 
+class SecretListStreamItem:
+    data: SecretListStreamItemData
+    """Blueprint properties"""
 
-class SecretVerifyParams:
-    secret_id: str
-    """The ID of the secret to be verified"""
+    type: SecretListStreamItemType
+    """The type of event"""
 
-    def __init__(self, secret_id: str) -> None:
-        self.secret_id = secret_id
+    def __init__(self, data: SecretListStreamItemData, type: SecretListStreamItemType) -> None:
+        self.data = data
+        self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretVerifyParams':
+    def from_dict(obj: Any) -> 'SecretListStreamItem':
         assert isinstance(obj, dict)
-        secret_id = from_str(obj.get("secretId"))
-        return SecretVerifyParams(secret_id)
+        data = SecretListStreamItemData.from_dict(obj.get("data"))
+        type = SecretListStreamItemType(obj.get("type"))
+        return SecretListStreamItem(data, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["secretId"] = from_str(self.secret_id)
+        result["data"] = to_class(SecretListStreamItemData, self.data)
+        result["type"] = to_enum(SecretListStreamItemType, self.type)
         return result
 
 
-class Type19(Enum):
-    """The type of action to take"""
-
-    AUTHENTICATE = "authenticate"
-
-
-class SecretVerifyResponseAction:
-    """The action to take next"""
-
-    type: Type19
-    """The type of action to take"""
+class SkillsetAbilityDeleteParams:
+    ability_id: str
+    """The ID of the ability to delete"""
 
-    url: str
-    """The URL to authenticate the secret"""
+    skillset_id: str
+    """The ID of the skillset"""
 
-    def __init__(self, type: Type19, url: str) -> None:
-        self.type = type
-        self.url = url
+    def __init__(self, ability_id: str, skillset_id: str) -> None:
+        self.ability_id = ability_id
+        self.skillset_id = skillset_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretVerifyResponseAction':
+    def from_dict(obj: Any) -> 'SkillsetAbilityDeleteParams':
         assert isinstance(obj, dict)
-        type = Type19(obj.get("type"))
-        url = from_str(obj.get("url"))
-        return SecretVerifyResponseAction(type, url)
+        ability_id = from_str(obj.get("abilityId"))
+        skillset_id = from_str(obj.get("skillsetId"))
+        return SkillsetAbilityDeleteParams(ability_id, skillset_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["type"] = to_enum(Type19, self.type)
-        result["url"] = from_str(self.url)
+        result["abilityId"] = from_str(self.ability_id)
+        result["skillsetId"] = from_str(self.skillset_id)
         return result
 
 
-class SecretVerifyResponseStatus(Enum):
-    """The status of the secret"""
-
-    AUTHENTICATED = "authenticated"
-    UNAUTHENTICATED = "unauthenticated"
-
-
-class SecretVerifyResponse:
-    action: Optional[SecretVerifyResponseAction]
+class SkillsetAbilityDeleteResponse:
     id: str
-    """The ID of the verified secret"""
-
-    status: SecretVerifyResponseStatus
-    """The status of the secret"""
+    """The ID of the deleted ability"""
 
-    def __init__(self, action: Optional[SecretVerifyResponseAction], id: str, status: SecretVerifyResponseStatus) -> None:
-        self.action = action
+    def __init__(self, id: str) -> None:
         self.id = id
-        self.status = status
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretVerifyResponse':
+    def from_dict(obj: Any) -> 'SkillsetAbilityDeleteResponse':
         assert isinstance(obj, dict)
-        action = from_union([SecretVerifyResponseAction.from_dict, from_none], obj.get("action"))
         id = from_str(obj.get("id"))
-        status = SecretVerifyResponseStatus(obj.get("status"))
-        return SecretVerifyResponse(action, id, status)
+        return SkillsetAbilityDeleteResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.action is not None:
-            result["action"] = from_union([lambda x: to_class(SecretVerifyResponseAction, x), from_none], self.action)
         result["id"] = from_str(self.id)
-        result["status"] = to_enum(SecretVerifyResponseStatus, self.status)
         return result
 
 
-class SecretCreateRequestKind(Enum):
-    """The kind of the secret"""
+class SkillsetAbilityExecuteParams:
+    ability_id: str
+    """The ID of the ability to execute"""
 
-    PERSONAL = "personal"
-    SHARED = "shared"
+    skillset_id: str
+    """The ID of the skillset containing the ability"""
 
+    def __init__(self, ability_id: str, skillset_id: str) -> None:
+        self.ability_id = ability_id
+        self.skillset_id = skillset_id
 
-class SecretCreateRequestType(Enum):
-    """The type of the secret"""
+    @staticmethod
+    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteParams':
+        assert isinstance(obj, dict)
+        ability_id = from_str(obj.get("abilityId"))
+        skillset_id = from_str(obj.get("skillsetId"))
+        return SkillsetAbilityExecuteParams(ability_id, skillset_id)
 
-    BASIC = "basic"
-    BEARER = "bearer"
-    JWT = "jwt"
-    OAUTH = "oauth"
-    PLAIN = "plain"
-    REFERENCE = "reference"
-    TEMPLATE = "template"
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["abilityId"] = from_str(self.ability_id)
+        result["skillsetId"] = from_str(self.skillset_id)
+        return result
 
 
-class SecretCreateRequestVisibility(Enum):
-    """The visibility of the secret"""
+class SkillsetAbilityExecuteRequest:
+    contact_id: Optional[str]
+    """The ID of the contact to associate with the execution"""
 
-    PRIVATE = "private"
-    PROTECTED = "protected"
-    PUBLIC = "public"
+    input: Optional[str]
+    """The input to process with the ability. This can be structured
+    text such as JSON or YAML for precise parameter control, or
+    unstructured natural language text. When unstructured text is
+    provided, the system will automatically detect and extract the
+    relevant parameters from the input.
+    """
 
+    def __init__(self, contact_id: Optional[str], input: Optional[str]) -> None:
+        self.contact_id = contact_id
+        self.input = input
 
-class SecretCreateRequest:
-    """Blueprint properties"""
+    @staticmethod
+    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteRequest':
+        assert isinstance(obj, dict)
+        contact_id = from_union([from_str, from_none], obj.get("contactId"))
+        input = from_union([from_str, from_none], obj.get("input"))
+        return SkillsetAbilityExecuteRequest(contact_id, input)
 
-    alias: Optional[str]
-    """The unique alias for the instance"""
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.contact_id is not None:
+            result["contactId"] = from_union([from_str, from_none], self.contact_id)
+        if self.input is not None:
+            result["input"] = from_union([from_str, from_none], self.input)
+        return result
 
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
 
-    config: Optional[Dict[str, Any]]
-    """The config of the secret"""
+class Type22(Enum):
+    """The type of the message"""
 
-    description: Optional[str]
-    """The associated description"""
+    ACTIVITY = "activity"
+    BACKSTORY = "backstory"
+    BOT = "bot"
+    CHECKPOINT = "checkpoint"
+    CONTEXT = "context"
+    INSTRUCTION = "instruction"
+    REASONING = "reasoning"
+    USER = "user"
 
-    kind: Optional[SecretCreateRequestKind]
-    """The kind of the secret"""
+
+class SkillsetAbilityExecuteResponseMessage:
+    """A message in the conversation"""
 
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
-    name: Optional[str]
-    """The associated name"""
-
-    type: Optional[SecretCreateRequestType]
-    """The type of the secret"""
-
-    value: Optional[str]
-    """The value of the secret"""
+    text: str
+    """The text of the message"""
 
-    visibility: Optional[SecretCreateRequestVisibility]
-    """The visibility of the secret"""
+    type: Type22
+    """The type of the message"""
 
-    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], config: Optional[Dict[str, Any]], description: Optional[str], kind: Optional[SecretCreateRequestKind], meta: Optional[Dict[str, Any]], name: Optional[str], type: Optional[SecretCreateRequestType], value: Optional[str], visibility: Optional[SecretCreateRequestVisibility]) -> None:
-        self.alias = alias
-        self.blueprint_id = blueprint_id
-        self.config = config
-        self.description = description
-        self.kind = kind
+    def __init__(self, meta: Optional[Dict[str, Any]], text: str, type: Type22) -> None:
         self.meta = meta
-        self.name = name
+        self.text = text
         self.type = type
-        self.value = value
-        self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretCreateRequest':
+    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteResponseMessage':
         assert isinstance(obj, dict)
-        alias = from_union([from_str, from_none], obj.get("alias"))
-        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
-        description = from_union([from_str, from_none], obj.get("description"))
-        kind = from_union([SecretCreateRequestKind, from_none], obj.get("kind"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        name = from_union([from_str, from_none], obj.get("name"))
-        type = from_union([SecretCreateRequestType, from_none], obj.get("type"))
-        value = from_union([from_str, from_none], obj.get("value"))
-        visibility = from_union([SecretCreateRequestVisibility, from_none], obj.get("visibility"))
-        return SecretCreateRequest(alias, blueprint_id, config, description, kind, meta, name, type, value, visibility)
+        text = from_str(obj.get("text"))
+        type = Type22(obj.get("type"))
+        return SkillsetAbilityExecuteResponseMessage(meta, text, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.alias is not None:
-            result["alias"] = from_union([from_str, from_none], self.alias)
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.config is not None:
-            result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
-        if self.description is not None:
-            result["description"] = from_union([from_str, from_none], self.description)
-        if self.kind is not None:
-            result["kind"] = from_union([lambda x: to_enum(SecretCreateRequestKind, x), from_none], self.kind)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        if self.name is not None:
-            result["name"] = from_union([from_str, from_none], self.name)
-        if self.type is not None:
-            result["type"] = from_union([lambda x: to_enum(SecretCreateRequestType, x), from_none], self.type)
-        if self.value is not None:
-            result["value"] = from_union([from_str, from_none], self.value)
-        if self.visibility is not None:
-            result["visibility"] = from_union([lambda x: to_enum(SecretCreateRequestVisibility, x), from_none], self.visibility)
+        result["text"] = from_str(self.text)
+        result["type"] = to_enum(Type22, self.type)
+        return result
+
+
+class SkillsetAbilityExecuteResponseUsage:
+    """Usage information"""
+
+    token: float
+    """The tokens used in this exchange"""
+
+    def __init__(self, token: float) -> None:
+        self.token = token
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteResponseUsage':
+        assert isinstance(obj, dict)
+        token = from_float(obj.get("token"))
+        return SkillsetAbilityExecuteResponseUsage(token)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["token"] = to_float(self.token)
         return result
 
 
-class SecretCreateResponse:
-    id: str
-    """The ID of the created secret"""
+class SkillsetAbilityExecuteResponse:
+    error: Optional[str]
+    """Error message if execution failed"""
 
-    def __init__(self, id: str) -> None:
-        self.id = id
+    messages: Optional[List[SkillsetAbilityExecuteResponseMessage]]
+    """Messages generated during execution"""
+
+    result: Any
+    """The result of the ability execution"""
+
+    usage: SkillsetAbilityExecuteResponseUsage
+    """Usage information"""
+
+    def __init__(self, error: Optional[str], messages: Optional[List[SkillsetAbilityExecuteResponseMessage]], result: Any, usage: SkillsetAbilityExecuteResponseUsage) -> None:
+        self.error = error
+        self.messages = messages
+        self.result = result
+        self.usage = usage
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretCreateResponse':
+    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteResponse':
         assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
-        return SecretCreateResponse(id)
+        error = from_union([from_str, from_none], obj.get("error"))
+        messages = from_union([lambda x: from_list(SkillsetAbilityExecuteResponseMessage.from_dict, x), from_none], obj.get("messages"))
+        result = obj.get("result")
+        usage = SkillsetAbilityExecuteResponseUsage.from_dict(obj.get("usage"))
+        return SkillsetAbilityExecuteResponse(error, messages, result, usage)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["id"] = from_str(self.id)
+        if self.error is not None:
+            result["error"] = from_union([from_str, from_none], self.error)
+        if self.messages is not None:
+            result["messages"] = from_union([lambda x: from_list(lambda x: to_class(SkillsetAbilityExecuteResponseMessage, x), x), from_none], self.messages)
+        if self.result is not None:
+            result["result"] = self.result
+        result["usage"] = to_class(SkillsetAbilityExecuteResponseUsage, self.usage)
         return result
 
 
-class SecretListParamsOrder(Enum):
-    """The order of the paginated items"""
+class Type23(Enum):
+    """The type of the message"""
 
-    ASC = "asc"
-    DESC = "desc"
+    ACTIVITY = "activity"
+    BACKSTORY = "backstory"
+    BOT = "bot"
+    CHECKPOINT = "checkpoint"
+    CONTEXT = "context"
+    INSTRUCTION = "instruction"
+    REASONING = "reasoning"
+    USER = "user"
 
 
-class SecretListParams:
-    cursor: Optional[str]
-    """The cursor to use for pagination"""
+class DataMessage:
+    """A message in the conversation"""
 
-    meta: Optional[Dict[str, str]]
-    """Key-value pairs to filter the partner users by metadata"""
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
 
-    order: Optional[SecretListParamsOrder]
-    """The order of the paginated items"""
+    text: str
+    """The text of the message"""
 
-    take: Optional[int]
-    """The number of items to retrieve"""
+    type: Type23
+    """The type of the message"""
 
-    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[SecretListParamsOrder], take: Optional[int]) -> None:
-        self.cursor = cursor
+    def __init__(self, meta: Optional[Dict[str, Any]], text: str, type: Type23) -> None:
         self.meta = meta
-        self.order = order
-        self.take = take
+        self.text = text
+        self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretListParams':
+    def from_dict(obj: Any) -> 'DataMessage':
         assert isinstance(obj, dict)
-        cursor = from_union([from_str, from_none], obj.get("cursor"))
-        meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
-        order = from_union([SecretListParamsOrder, from_none], obj.get("order"))
-        take = from_union([from_int, from_none], obj.get("take"))
-        return SecretListParams(cursor, meta, order, take)
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        text = from_str(obj.get("text"))
+        type = Type23(obj.get("type"))
+        return DataMessage(meta, text, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.cursor is not None:
-            result["cursor"] = from_union([from_str, from_none], self.cursor)
         if self.meta is not None:
-            result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
-        if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(SecretListParamsOrder, x), from_none], self.order)
-        if self.take is not None:
-            result["take"] = from_union([from_int, from_none], self.take)
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        result["text"] = from_str(self.text)
+        result["type"] = to_enum(Type23, self.type)
         return result
 
 
-class IndigoKind(Enum):
-    """The kind of the secret"""
-
-    PERSONAL = "personal"
-    SHARED = "shared"
+class Type24(Enum):
+    """The type of the message"""
 
+    ACTIVITY = "activity"
+    BACKSTORY = "backstory"
+    BOT = "bot"
+    CHECKPOINT = "checkpoint"
+    CONTEXT = "context"
+    INSTRUCTION = "instruction"
+    REASONING = "reasoning"
+    USER = "user"
 
-class Type20(Enum):
-    """The type of the secret"""
 
-    BASIC = "basic"
-    BEARER = "bearer"
-    JWT = "jwt"
-    OAUTH = "oauth"
-    PLAIN = "plain"
-    REFERENCE = "reference"
-    TEMPLATE = "template"
+class IndigoUsage:
+    """Usage information"""
 
+    token: float
+    """The tokens used in this exchange"""
 
-class FriskyVisibility(Enum):
-    """The visibility of the secret"""
+    def __init__(self, token: float) -> None:
+        self.token = token
 
-    PRIVATE = "private"
-    PROTECTED = "protected"
-    PUBLIC = "public"
+    @staticmethod
+    def from_dict(obj: Any) -> 'IndigoUsage':
+        assert isinstance(obj, dict)
+        token = from_float(obj.get("token"))
+        return IndigoUsage(token)
 
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["token"] = to_float(self.token)
+        return result
 
-class SecretListResponseItem:
-    """Blueprint properties"""
 
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
+class SkillsetAbilityExecuteStreamItemData:
+    """The data for the event
+    
+    A message in the conversation
+    
+    Information about an abort event in a streamed response
+    """
+    error: Optional[str]
+    """Error message if execution failed"""
 
-    config: Optional[Dict[str, Any]]
-    """The config of the secret"""
+    messages: Optional[List[DataMessage]]
+    """Messages generated during execution"""
 
-    created_at: float
-    """The timestamp (ms) when the instance was created"""
+    result: Any
+    """The result of the ability execution"""
 
-    description: Optional[str]
-    """The associated description"""
+    usage: Optional[IndigoUsage]
+    """Usage information"""
 
-    id: str
-    """The instance ID"""
+    message: Optional[str]
+    """The error message"""
 
-    kind: Optional[IndigoKind]
-    """The kind of the secret"""
+    token: Optional[str]
+    """The token generated"""
 
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
-    name: Optional[str]
-    """The associated name"""
+    text: Optional[str]
+    """The text of the message"""
 
-    type: Optional[Type20]
-    """The type of the secret"""
+    type: Optional[Type24]
+    """The type of the message"""
 
-    updated_at: float
-    """The timestamp (ms) when the instance was updated"""
+    function_name: Optional[str]
+    """The function or tool associated with the abort"""
 
-    visibility: Optional[FriskyVisibility]
-    """The visibility of the secret"""
+    reason: Any
+    """The abort reason if available"""
 
-    def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, kind: Optional[IndigoKind], meta: Optional[Dict[str, Any]], name: Optional[str], type: Optional[Type20], updated_at: float, visibility: Optional[FriskyVisibility]) -> None:
-        self.blueprint_id = blueprint_id
-        self.config = config
-        self.created_at = created_at
-        self.description = description
-        self.id = id
-        self.kind = kind
+    input_tokens_used: Optional[float]
+    """The number of input tokens used"""
+
+    model: Optional[str]
+    """The model used"""
+
+    output_tokens_used: Optional[float]
+    """The number of output tokens used"""
+
+    def __init__(self, error: Optional[str], messages: Optional[List[DataMessage]], result: Any, usage: Optional[IndigoUsage], message: Optional[str], token: Optional[str], meta: Optional[Dict[str, Any]], text: Optional[str], type: Optional[Type24], function_name: Optional[str], reason: Any, input_tokens_used: Optional[float], model: Optional[str], output_tokens_used: Optional[float]) -> None:
+        self.error = error
+        self.messages = messages
+        self.result = result
+        self.usage = usage
+        self.message = message
+        self.token = token
         self.meta = meta
-        self.name = name
+        self.text = text
         self.type = type
-        self.updated_at = updated_at
-        self.visibility = visibility
+        self.function_name = function_name
+        self.reason = reason
+        self.input_tokens_used = input_tokens_used
+        self.model = model
+        self.output_tokens_used = output_tokens_used
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretListResponseItem':
+    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteStreamItemData':
         assert isinstance(obj, dict)
-        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
-        created_at = from_float(obj.get("createdAt"))
-        description = from_union([from_str, from_none], obj.get("description"))
-        id = from_str(obj.get("id"))
-        kind = from_union([IndigoKind, from_none], obj.get("kind"))
+        error = from_union([from_str, from_none], obj.get("error"))
+        messages = from_union([lambda x: from_list(DataMessage.from_dict, x), from_none], obj.get("messages"))
+        result = obj.get("result")
+        usage = from_union([IndigoUsage.from_dict, from_none], obj.get("usage"))
+        message = from_union([from_str, from_none], obj.get("message"))
+        token = from_union([from_str, from_none], obj.get("token"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        name = from_union([from_str, from_none], obj.get("name"))
-        type = from_union([Type20, from_none], obj.get("type"))
-        updated_at = from_float(obj.get("updatedAt"))
-        visibility = from_union([FriskyVisibility, from_none], obj.get("visibility"))
-        return SecretListResponseItem(blueprint_id, config, created_at, description, id, kind, meta, name, type, updated_at, visibility)
+        text = from_union([from_str, from_none], obj.get("text"))
+        type = from_union([Type24, from_none], obj.get("type"))
+        function_name = from_union([from_str, from_none], obj.get("functionName"))
+        reason = obj.get("reason")
+        input_tokens_used = from_union([from_float, from_none], obj.get("inputTokensUsed"))
+        model = from_union([from_str, from_none], obj.get("model"))
+        output_tokens_used = from_union([from_float, from_none], obj.get("outputTokensUsed"))
+        return SkillsetAbilityExecuteStreamItemData(error, messages, result, usage, message, token, meta, text, type, function_name, reason, input_tokens_used, model, output_tokens_used)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.config is not None:
-            result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
-        result["createdAt"] = to_float(self.created_at)
-        if self.description is not None:
-            result["description"] = from_union([from_str, from_none], self.description)
-        result["id"] = from_str(self.id)
-        if self.kind is not None:
-            result["kind"] = from_union([lambda x: to_enum(IndigoKind, x), from_none], self.kind)
+        if self.error is not None:
+            result["error"] = from_union([from_str, from_none], self.error)
+        if self.messages is not None:
+            result["messages"] = from_union([lambda x: from_list(lambda x: to_class(DataMessage, x), x), from_none], self.messages)
+        if self.result is not None:
+            result["result"] = self.result
+        if self.usage is not None:
+            result["usage"] = from_union([lambda x: to_class(IndigoUsage, x), from_none], self.usage)
+        if self.message is not None:
+            result["message"] = from_union([from_str, from_none], self.message)
+        if self.token is not None:
+            result["token"] = from_union([from_str, from_none], self.token)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        if self.name is not None:
-            result["name"] = from_union([from_str, from_none], self.name)
+        if self.text is not None:
+            result["text"] = from_union([from_str, from_none], self.text)
         if self.type is not None:
-            result["type"] = from_union([lambda x: to_enum(Type20, x), from_none], self.type)
-        result["updatedAt"] = to_float(self.updated_at)
-        if self.visibility is not None:
-            result["visibility"] = from_union([lambda x: to_enum(FriskyVisibility, x), from_none], self.visibility)
+            result["type"] = from_union([lambda x: to_enum(Type24, x), from_none], self.type)
+        if self.function_name is not None:
+            result["functionName"] = from_union([from_str, from_none], self.function_name)
+        if self.reason is not None:
+            result["reason"] = self.reason
+        if self.input_tokens_used is not None:
+            result["inputTokensUsed"] = from_union([to_float, from_none], self.input_tokens_used)
+        if self.model is not None:
+            result["model"] = from_union([from_str, from_none], self.model)
+        if self.output_tokens_used is not None:
+            result["outputTokensUsed"] = from_union([to_float, from_none], self.output_tokens_used)
         return result
 
 
-class SecretListResponse:
-    cursor: str
-    """Cursor for fetching the next page"""
+class SkillsetAbilityExecuteStreamItemType(Enum):
+    """The type of event"""
 
-    items: List[SecretListResponseItem]
+    ABORT = "abort"
+    COMPLETE_BEGIN = "completeBegin"
+    COMPLETE_END = "completeEnd"
+    ERROR = "error"
+    MESSAGE = "message"
+    REASONING_TOKEN = "reasoningToken"
+    RESULT = "result"
+    TOKEN = "token"
+    USAGE = "usage"
+    WAIT_FOR_CHANNEL_MESSAGE_BEGIN = "waitForChannelMessageBegin"
+    WAIT_FOR_CHANNEL_MESSAGE_END = "waitForChannelMessageEnd"
 
-    def __init__(self, cursor: str, items: List[SecretListResponseItem]) -> None:
-        self.cursor = cursor
-        self.items = items
+
+class SkillsetAbilityExecuteStreamItem:
+    data: SkillsetAbilityExecuteStreamItemData
+    """The data for the event
+    
+    A message in the conversation
+    
+    Information about an abort event in a streamed response
+    """
+    type: SkillsetAbilityExecuteStreamItemType
+    """The type of event"""
+
+    def __init__(self, data: SkillsetAbilityExecuteStreamItemData, type: SkillsetAbilityExecuteStreamItemType) -> None:
+        self.data = data
+        self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretListResponse':
+    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteStreamItem':
         assert isinstance(obj, dict)
-        cursor = from_str(obj.get("cursor"))
-        items = from_list(SecretListResponseItem.from_dict, obj.get("items"))
-        return SecretListResponse(cursor, items)
+        data = SkillsetAbilityExecuteStreamItemData.from_dict(obj.get("data"))
+        type = SkillsetAbilityExecuteStreamItemType(obj.get("type"))
+        return SkillsetAbilityExecuteStreamItem(data, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["cursor"] = from_str(self.cursor)
-        result["items"] = from_list(lambda x: to_class(SecretListResponseItem, x), self.items)
+        result["data"] = to_class(SkillsetAbilityExecuteStreamItemData, self.data)
+        result["type"] = to_enum(SkillsetAbilityExecuteStreamItemType, self.type)
         return result
 
 
-class IndecentKind(Enum):
-    """The kind of the secret"""
-
-    PERSONAL = "personal"
-    SHARED = "shared"
-
-
-class Type21(Enum):
-    """The type of the secret"""
+class SkillsetAbilityFetchParams:
+    ability_id: str
+    """The ID of the ability to retrieve"""
 
-    BASIC = "basic"
-    BEARER = "bearer"
-    JWT = "jwt"
-    OAUTH = "oauth"
-    PLAIN = "plain"
-    REFERENCE = "reference"
-    TEMPLATE = "template"
+    skillset_id: str
+    """The ID of the skillset"""
 
+    def __init__(self, ability_id: str, skillset_id: str) -> None:
+        self.ability_id = ability_id
+        self.skillset_id = skillset_id
 
-class MischievousVisibility(Enum):
-    """The visibility of the secret"""
+    @staticmethod
+    def from_dict(obj: Any) -> 'SkillsetAbilityFetchParams':
+        assert isinstance(obj, dict)
+        ability_id = from_str(obj.get("abilityId"))
+        skillset_id = from_str(obj.get("skillsetId"))
+        return SkillsetAbilityFetchParams(ability_id, skillset_id)
 
-    PRIVATE = "private"
-    PROTECTED = "protected"
-    PUBLIC = "public"
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["abilityId"] = from_str(self.ability_id)
+        result["skillsetId"] = from_str(self.skillset_id)
+        return result
 
 
-class SecretListStreamItemData:
+class SkillsetAbilityFetchResponse:
     """Blueprint properties"""
 
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    config: Optional[Dict[str, Any]]
-    """The config of the secret"""
+    bot_id: Optional[str]
+    """The ID of the bot associated with the ability"""
 
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
-    description: Optional[str]
+    description: str
     """The associated description"""
 
+    file_id: Optional[str]
+    """The ID of the file associated with the ability"""
+
     id: str
     """The instance ID"""
 
-    kind: Optional[IndecentKind]
-    """The kind of the secret"""
+    instruction: str
+    """The instruction of the skillset ability"""
 
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
-    name: Optional[str]
+    name: str
     """The associated name"""
 
-    type: Optional[Type21]
-    """The type of the secret"""
+    secret_id: Optional[str]
+    """The ID of the secret associated with the ability"""
+
+    space_id: Optional[str]
+    """The ID of the space associated with the ability"""
 
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    visibility: Optional[MischievousVisibility]
-    """The visibility of the secret"""
-
-    def __init__(self, blueprint_id: Optional[str], config: Optional[Dict[str, Any]], created_at: float, description: Optional[str], id: str, kind: Optional[IndecentKind], meta: Optional[Dict[str, Any]], name: Optional[str], type: Optional[Type21], updated_at: float, visibility: Optional[MischievousVisibility]) -> None:
+    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: str, file_id: Optional[str], id: str, instruction: str, meta: Optional[Dict[str, Any]], name: str, secret_id: Optional[str], space_id: Optional[str], updated_at: float) -> None:
         self.blueprint_id = blueprint_id
-        self.config = config
+        self.bot_id = bot_id
         self.created_at = created_at
         self.description = description
+        self.file_id = file_id
         self.id = id
-        self.kind = kind
+        self.instruction = instruction
         self.meta = meta
         self.name = name
-        self.type = type
+        self.secret_id = secret_id
+        self.space_id = space_id
         self.updated_at = updated_at
-        self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretListStreamItemData':
+    def from_dict(obj: Any) -> 'SkillsetAbilityFetchResponse':
         assert isinstance(obj, dict)
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        config = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("config"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
         created_at = from_float(obj.get("createdAt"))
-        description = from_union([from_str, from_none], obj.get("description"))
+        description = from_str(obj.get("description"))
+        file_id = from_union([from_str, from_none], obj.get("fileId"))
         id = from_str(obj.get("id"))
-        kind = from_union([IndecentKind, from_none], obj.get("kind"))
+        instruction = from_str(obj.get("instruction"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        name = from_union([from_str, from_none], obj.get("name"))
-        type = from_union([Type21, from_none], obj.get("type"))
+        name = from_str(obj.get("name"))
+        secret_id = from_union([from_str, from_none], obj.get("secretId"))
+        space_id = from_union([from_str, from_none], obj.get("spaceId"))
         updated_at = from_float(obj.get("updatedAt"))
-        visibility = from_union([MischievousVisibility, from_none], obj.get("visibility"))
-        return SecretListStreamItemData(blueprint_id, config, created_at, description, id, kind, meta, name, type, updated_at, visibility)
+        return SkillsetAbilityFetchResponse(blueprint_id, bot_id, created_at, description, file_id, id, instruction, meta, name, secret_id, space_id, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.config is not None:
-            result["config"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.config)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
         result["createdAt"] = to_float(self.created_at)
-        if self.description is not None:
-            result["description"] = from_union([from_str, from_none], self.description)
+        result["description"] = from_str(self.description)
+        if self.file_id is not None:
+            result["fileId"] = from_union([from_str, from_none], self.file_id)
         result["id"] = from_str(self.id)
-        if self.kind is not None:
-            result["kind"] = from_union([lambda x: to_enum(IndecentKind, x), from_none], self.kind)
+        result["instruction"] = from_str(self.instruction)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        if self.name is not None:
-            result["name"] = from_union([from_str, from_none], self.name)
-        if self.type is not None:
-            result["type"] = from_union([lambda x: to_enum(Type21, x), from_none], self.type)
+        result["name"] = from_str(self.name)
+        if self.secret_id is not None:
+            result["secretId"] = from_union([from_str, from_none], self.secret_id)
+        if self.space_id is not None:
+            result["spaceId"] = from_union([from_str, from_none], self.space_id)
         result["updatedAt"] = to_float(self.updated_at)
-        if self.visibility is not None:
-            result["visibility"] = from_union([lambda x: to_enum(MischievousVisibility, x), from_none], self.visibility)
         return result
 
 
-class SecretListStreamItemType(Enum):
-    """The type of event"""
-
-    ITEM = "item"
-
-
-class SecretListStreamItem:
-    data: SecretListStreamItemData
-    """Blueprint properties"""
-
-    type: SecretListStreamItemType
-    """The type of event"""
+class SkillsetAbilityUpdateParams:
+    ability_id: str
+    skillset_id: str
 
-    def __init__(self, data: SecretListStreamItemData, type: SecretListStreamItemType) -> None:
-        self.data = data
-        self.type = type
+    def __init__(self, ability_id: str, skillset_id: str) -> None:
+        self.ability_id = ability_id
+        self.skillset_id = skillset_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SecretListStreamItem':
+    def from_dict(obj: Any) -> 'SkillsetAbilityUpdateParams':
         assert isinstance(obj, dict)
-        data = SecretListStreamItemData.from_dict(obj.get("data"))
-        type = SecretListStreamItemType(obj.get("type"))
-        return SecretListStreamItem(data, type)
+        ability_id = from_str(obj.get("abilityId"))
+        skillset_id = from_str(obj.get("skillsetId"))
+        return SkillsetAbilityUpdateParams(ability_id, skillset_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["data"] = to_class(SecretListStreamItemData, self.data)
-        result["type"] = to_enum(SecretListStreamItemType, self.type)
+        result["abilityId"] = from_str(self.ability_id)
+        result["skillsetId"] = from_str(self.skillset_id)
         return result
 
 
-class SkillsetAbilityDeleteParams:
-    ability_id: str
-    """The ID of the ability to delete"""
+class SkillsetAbilityUpdateRequest:
+    """Blueprint properties"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    bot_id: Optional[str]
+    """The ID of the bot associated with the ability"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    file_id: Optional[str]
+    """The ID of the file associated with the ability"""
+
+    instruction: Optional[str]
+    """The text to update the ability with"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    secret_id: Optional[str]
+    """The ID of the secret associated with the ability"""
 
-    skillset_id: str
-    """The ID of the skillset"""
+    space_id: Optional[str]
+    """The ID of the space associated with the ability"""
 
-    def __init__(self, ability_id: str, skillset_id: str) -> None:
-        self.ability_id = ability_id
-        self.skillset_id = skillset_id
+    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], file_id: Optional[str], instruction: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], secret_id: Optional[str], space_id: Optional[str]) -> None:
+        self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
+        self.description = description
+        self.file_id = file_id
+        self.instruction = instruction
+        self.meta = meta
+        self.name = name
+        self.secret_id = secret_id
+        self.space_id = space_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityDeleteParams':
+    def from_dict(obj: Any) -> 'SkillsetAbilityUpdateRequest':
         assert isinstance(obj, dict)
-        ability_id = from_str(obj.get("abilityId"))
-        skillset_id = from_str(obj.get("skillsetId"))
-        return SkillsetAbilityDeleteParams(ability_id, skillset_id)
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        file_id = from_union([from_str, from_none], obj.get("fileId"))
+        instruction = from_union([from_str, from_none], obj.get("instruction"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        secret_id = from_union([from_str, from_none], obj.get("secretId"))
+        space_id = from_union([from_str, from_none], obj.get("spaceId"))
+        return SkillsetAbilityUpdateRequest(blueprint_id, bot_id, description, file_id, instruction, meta, name, secret_id, space_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["abilityId"] = from_str(self.ability_id)
-        result["skillsetId"] = from_str(self.skillset_id)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        if self.file_id is not None:
+            result["fileId"] = from_union([from_str, from_none], self.file_id)
+        if self.instruction is not None:
+            result["instruction"] = from_union([from_str, from_none], self.instruction)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.secret_id is not None:
+            result["secretId"] = from_union([from_str, from_none], self.secret_id)
+        if self.space_id is not None:
+            result["spaceId"] = from_union([from_str, from_none], self.space_id)
         return result
 
 
-class SkillsetAbilityDeleteResponse:
+class SkillsetAbilityUpdateResponse:
     id: str
-    """The ID of the deleted ability"""
+    """The ID of the updated ability"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityDeleteResponse':
+    def from_dict(obj: Any) -> 'SkillsetAbilityUpdateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return SkillsetAbilityDeleteResponse(id)
+        return SkillsetAbilityUpdateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -42576,440 +44743,453 @@ def to_dict(self) -> dict:
         return result
 
 
-class SkillsetAbilityExecuteParams:
-    ability_id: str
-    """The ID of the ability to execute"""
-
+class SkillsetAbilityCreateParams:
     skillset_id: str
-    """The ID of the skillset containing the ability"""
 
-    def __init__(self, ability_id: str, skillset_id: str) -> None:
-        self.ability_id = ability_id
+    def __init__(self, skillset_id: str) -> None:
         self.skillset_id = skillset_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteParams':
+    def from_dict(obj: Any) -> 'SkillsetAbilityCreateParams':
         assert isinstance(obj, dict)
-        ability_id = from_str(obj.get("abilityId"))
         skillset_id = from_str(obj.get("skillsetId"))
-        return SkillsetAbilityExecuteParams(ability_id, skillset_id)
+        return SkillsetAbilityCreateParams(skillset_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["abilityId"] = from_str(self.ability_id)
         result["skillsetId"] = from_str(self.skillset_id)
         return result
 
 
-class SkillsetAbilityExecuteRequest:
-    contact_id: Optional[str]
-    """The ID of the contact to associate with the execution"""
-
-    input: Optional[str]
-    """The input to process with the ability. This can be structured
-    text such as JSON or YAML for precise parameter control, or
-    unstructured natural language text. When unstructured text is
-    provided, the system will automatically detect and extract the
-    relevant parameters from the input.
-    """
-
-    def __init__(self, contact_id: Optional[str], input: Optional[str]) -> None:
-        self.contact_id = contact_id
-        self.input = input
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteRequest':
-        assert isinstance(obj, dict)
-        contact_id = from_union([from_str, from_none], obj.get("contactId"))
-        input = from_union([from_str, from_none], obj.get("input"))
-        return SkillsetAbilityExecuteRequest(contact_id, input)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        if self.contact_id is not None:
-            result["contactId"] = from_union([from_str, from_none], self.contact_id)
-        if self.input is not None:
-            result["input"] = from_union([from_str, from_none], self.input)
-        return result
+class SkillsetAbilityCreateRequest:
+    """Blueprint properties"""
 
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
 
-class Type22(Enum):
-    """The type of the message"""
+    bot_id: Optional[str]
+    """The ID of the bot associated with the ability"""
 
-    ACTIVITY = "activity"
-    BACKSTORY = "backstory"
-    BOT = "bot"
-    CHECKPOINT = "checkpoint"
-    CONTEXT = "context"
-    INSTRUCTION = "instruction"
-    REASONING = "reasoning"
-    USER = "user"
+    description: Optional[str]
+    """The associated description"""
 
+    file_id: Optional[str]
+    """The ID of the file associated with the ability"""
 
-class SkillsetAbilityExecuteResponseMessage:
-    """A message in the conversation"""
+    instruction: Optional[str]
+    """The instruction of the ability"""
 
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
-    text: str
-    """The text of the message"""
+    name: Optional[str]
+    """The associated name"""
 
-    type: Type22
-    """The type of the message"""
+    secret_id: Optional[str]
+    """The ID of the secret associated with the ability"""
 
-    def __init__(self, meta: Optional[Dict[str, Any]], text: str, type: Type22) -> None:
+    space_id: Optional[str]
+    """The ID of the space associated with the ability"""
+
+    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], file_id: Optional[str], instruction: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], secret_id: Optional[str], space_id: Optional[str]) -> None:
+        self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
+        self.description = description
+        self.file_id = file_id
+        self.instruction = instruction
         self.meta = meta
-        self.text = text
-        self.type = type
+        self.name = name
+        self.secret_id = secret_id
+        self.space_id = space_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteResponseMessage':
+    def from_dict(obj: Any) -> 'SkillsetAbilityCreateRequest':
         assert isinstance(obj, dict)
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        file_id = from_union([from_str, from_none], obj.get("fileId"))
+        instruction = from_union([from_str, from_none], obj.get("instruction"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        text = from_str(obj.get("text"))
-        type = Type22(obj.get("type"))
-        return SkillsetAbilityExecuteResponseMessage(meta, text, type)
+        name = from_union([from_str, from_none], obj.get("name"))
+        secret_id = from_union([from_str, from_none], obj.get("secretId"))
+        space_id = from_union([from_str, from_none], obj.get("spaceId"))
+        return SkillsetAbilityCreateRequest(blueprint_id, bot_id, description, file_id, instruction, meta, name, secret_id, space_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        if self.file_id is not None:
+            result["fileId"] = from_union([from_str, from_none], self.file_id)
+        if self.instruction is not None:
+            result["instruction"] = from_union([from_str, from_none], self.instruction)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        result["text"] = from_str(self.text)
-        result["type"] = to_enum(Type22, self.type)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.secret_id is not None:
+            result["secretId"] = from_union([from_str, from_none], self.secret_id)
+        if self.space_id is not None:
+            result["spaceId"] = from_union([from_str, from_none], self.space_id)
         return result
 
 
-class SkillsetAbilityExecuteResponseUsage:
-    """Usage information"""
-
-    token: float
-    """The tokens used in this exchange"""
+class SkillsetAbilityCreateResponse:
+    id: str
+    """The ID of the created ability"""
 
-    def __init__(self, token: float) -> None:
-        self.token = token
+    def __init__(self, id: str) -> None:
+        self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteResponseUsage':
+    def from_dict(obj: Any) -> 'SkillsetAbilityCreateResponse':
         assert isinstance(obj, dict)
-        token = from_float(obj.get("token"))
-        return SkillsetAbilityExecuteResponseUsage(token)
+        id = from_str(obj.get("id"))
+        return SkillsetAbilityCreateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["token"] = to_float(self.token)
+        result["id"] = from_str(self.id)
         return result
 
 
-class SkillsetAbilityExecuteResponse:
-    error: Optional[str]
-    """Error message if execution failed"""
+class SkillsetAbilitiesExportParamsOrder(Enum):
+    """The order of the paginated items"""
 
-    messages: Optional[List[SkillsetAbilityExecuteResponseMessage]]
-    """Messages generated during execution"""
+    ASC = "asc"
+    DESC = "desc"
 
-    result: Any
-    """The result of the ability execution"""
 
-    usage: SkillsetAbilityExecuteResponseUsage
-    """Usage information"""
+class SkillsetAbilitiesExportParams:
+    cursor: Optional[str]
+    """The cursor to use for pagination"""
 
-    def __init__(self, error: Optional[str], messages: Optional[List[SkillsetAbilityExecuteResponseMessage]], result: Any, usage: SkillsetAbilityExecuteResponseUsage) -> None:
-        self.error = error
-        self.messages = messages
-        self.result = result
-        self.usage = usage
+    order: Optional[SkillsetAbilitiesExportParamsOrder]
+    """The order of the paginated items"""
+
+    skillset_id: str
+    """The ID of the skillset to export"""
+
+    take: Optional[int]
+    """The number of items to retrieve"""
+
+    def __init__(self, cursor: Optional[str], order: Optional[SkillsetAbilitiesExportParamsOrder], skillset_id: str, take: Optional[int]) -> None:
+        self.cursor = cursor
+        self.order = order
+        self.skillset_id = skillset_id
+        self.take = take
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteResponse':
+    def from_dict(obj: Any) -> 'SkillsetAbilitiesExportParams':
         assert isinstance(obj, dict)
-        error = from_union([from_str, from_none], obj.get("error"))
-        messages = from_union([lambda x: from_list(SkillsetAbilityExecuteResponseMessage.from_dict, x), from_none], obj.get("messages"))
-        result = obj.get("result")
-        usage = SkillsetAbilityExecuteResponseUsage.from_dict(obj.get("usage"))
-        return SkillsetAbilityExecuteResponse(error, messages, result, usage)
+        cursor = from_union([from_str, from_none], obj.get("cursor"))
+        order = from_union([SkillsetAbilitiesExportParamsOrder, from_none], obj.get("order"))
+        skillset_id = from_str(obj.get("skillsetId"))
+        take = from_union([from_int, from_none], obj.get("take"))
+        return SkillsetAbilitiesExportParams(cursor, order, skillset_id, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.error is not None:
-            result["error"] = from_union([from_str, from_none], self.error)
-        if self.messages is not None:
-            result["messages"] = from_union([lambda x: from_list(lambda x: to_class(SkillsetAbilityExecuteResponseMessage, x), x), from_none], self.messages)
-        if self.result is not None:
-            result["result"] = self.result
-        result["usage"] = to_class(SkillsetAbilityExecuteResponseUsage, self.usage)
+        if self.cursor is not None:
+            result["cursor"] = from_union([from_str, from_none], self.cursor)
+        if self.order is not None:
+            result["order"] = from_union([lambda x: to_enum(SkillsetAbilitiesExportParamsOrder, x), from_none], self.order)
+        result["skillsetId"] = from_str(self.skillset_id)
+        if self.take is not None:
+            result["take"] = from_union([from_int, from_none], self.take)
         return result
 
 
-class Type23(Enum):
-    """The type of the message"""
+class SkillsetAbilitiesExportResponseItem:
+    """Blueprint properties"""
 
-    ACTIVITY = "activity"
-    BACKSTORY = "backstory"
-    BOT = "bot"
-    CHECKPOINT = "checkpoint"
-    CONTEXT = "context"
-    INSTRUCTION = "instruction"
-    REASONING = "reasoning"
-    USER = "user"
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    bot_id: Optional[str]
+    """The ID of the bot associated with the ability"""
 
+    created_at: float
+    """The timestamp (ms) when the instance was created"""
 
-class DataMessage:
-    """A message in the conversation"""
+    description: str
+    """The associated description"""
 
+    file_id: Optional[str]
+    """The ID of the file associated with the ability"""
+
+    id: str
+    """The instance ID"""
+
+    instruction: str
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
-    text: str
-    """The text of the message"""
+    name: str
+    """The associated name"""
 
-    type: Type23
-    """The type of the message"""
+    secret_id: Optional[str]
+    """The ID of the secret associated with the ability"""
 
-    def __init__(self, meta: Optional[Dict[str, Any]], text: str, type: Type23) -> None:
+    space_id: Optional[str]
+    """The ID of the space associated with the ability"""
+
+    updated_at: float
+    """The timestamp (ms) when the instance was updated"""
+
+    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: str, file_id: Optional[str], id: str, instruction: str, meta: Optional[Dict[str, Any]], name: str, secret_id: Optional[str], space_id: Optional[str], updated_at: float) -> None:
+        self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
+        self.created_at = created_at
+        self.description = description
+        self.file_id = file_id
+        self.id = id
+        self.instruction = instruction
         self.meta = meta
-        self.text = text
-        self.type = type
+        self.name = name
+        self.secret_id = secret_id
+        self.space_id = space_id
+        self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'DataMessage':
+    def from_dict(obj: Any) -> 'SkillsetAbilitiesExportResponseItem':
         assert isinstance(obj, dict)
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        created_at = from_float(obj.get("createdAt"))
+        description = from_str(obj.get("description"))
+        file_id = from_union([from_str, from_none], obj.get("fileId"))
+        id = from_str(obj.get("id"))
+        instruction = from_str(obj.get("instruction"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        text = from_str(obj.get("text"))
-        type = Type23(obj.get("type"))
-        return DataMessage(meta, text, type)
+        name = from_str(obj.get("name"))
+        secret_id = from_union([from_str, from_none], obj.get("secretId"))
+        space_id = from_union([from_str, from_none], obj.get("spaceId"))
+        updated_at = from_float(obj.get("updatedAt"))
+        return SkillsetAbilitiesExportResponseItem(blueprint_id, bot_id, created_at, description, file_id, id, instruction, meta, name, secret_id, space_id, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        result["createdAt"] = to_float(self.created_at)
+        result["description"] = from_str(self.description)
+        if self.file_id is not None:
+            result["fileId"] = from_union([from_str, from_none], self.file_id)
+        result["id"] = from_str(self.id)
+        result["instruction"] = from_str(self.instruction)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        result["text"] = from_str(self.text)
-        result["type"] = to_enum(Type23, self.type)
+        result["name"] = from_str(self.name)
+        if self.secret_id is not None:
+            result["secretId"] = from_union([from_str, from_none], self.secret_id)
+        if self.space_id is not None:
+            result["spaceId"] = from_union([from_str, from_none], self.space_id)
+        result["updatedAt"] = to_float(self.updated_at)
         return result
 
 
-class Type24(Enum):
-    """The type of the message"""
-
-    ACTIVITY = "activity"
-    BACKSTORY = "backstory"
-    BOT = "bot"
-    CHECKPOINT = "checkpoint"
-    CONTEXT = "context"
-    INSTRUCTION = "instruction"
-    REASONING = "reasoning"
-    USER = "user"
-
-
-class IndigoUsage:
-    """Usage information"""
+class SkillsetAbilitiesExportResponse:
+    cursor: str
+    """Cursor for fetching the next page"""
 
-    token: float
-    """The tokens used in this exchange"""
+    items: List[SkillsetAbilitiesExportResponseItem]
 
-    def __init__(self, token: float) -> None:
-        self.token = token
+    def __init__(self, cursor: str, items: List[SkillsetAbilitiesExportResponseItem]) -> None:
+        self.cursor = cursor
+        self.items = items
 
     @staticmethod
-    def from_dict(obj: Any) -> 'IndigoUsage':
+    def from_dict(obj: Any) -> 'SkillsetAbilitiesExportResponse':
         assert isinstance(obj, dict)
-        token = from_float(obj.get("token"))
-        return IndigoUsage(token)
+        cursor = from_str(obj.get("cursor"))
+        items = from_list(SkillsetAbilitiesExportResponseItem.from_dict, obj.get("items"))
+        return SkillsetAbilitiesExportResponse(cursor, items)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["token"] = to_float(self.token)
+        result["cursor"] = from_str(self.cursor)
+        result["items"] = from_list(lambda x: to_class(SkillsetAbilitiesExportResponseItem, x), self.items)
         return result
 
 
-class SkillsetAbilityExecuteStreamItemData:
-    """The data for the event
-    
-    A message in the conversation
-    
-    Information about an abort event in a streamed response
-    """
-    error: Optional[str]
-    """Error message if execution failed"""
+class SkillsetAbilitiesExportStreamItemData:
+    """Blueprint properties"""
 
-    messages: Optional[List[DataMessage]]
-    """Messages generated during execution"""
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
 
-    result: Any
-    """The result of the ability execution"""
+    bot_id: Optional[str]
+    """The ID of the bot associated with the ability"""
 
-    usage: Optional[IndigoUsage]
-    """Usage information"""
+    created_at: float
+    """The timestamp (ms) when the instance was created"""
 
-    message: Optional[str]
-    """The error message"""
+    description: str
+    """The associated description"""
 
-    token: Optional[str]
-    """The token generated"""
+    file_id: Optional[str]
+    """The ID of the file associated with the ability"""
+
+    id: str
+    """The instance ID"""
 
+    instruction: str
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
-    text: Optional[str]
-    """The text of the message"""
-
-    type: Optional[Type24]
-    """The type of the message"""
-
-    function_name: Optional[str]
-    """The function or tool associated with the abort"""
-
-    reason: Any
-    """The abort reason if available"""
+    name: str
+    """The associated name"""
 
-    input_tokens_used: Optional[float]
-    """The number of input tokens used"""
+    secret_id: Optional[str]
+    """The ID of the secret associated with the ability"""
 
-    model: Optional[str]
-    """The model used"""
+    space_id: Optional[str]
+    """The ID of the space associated with the ability"""
 
-    output_tokens_used: Optional[float]
-    """The number of output tokens used"""
+    updated_at: float
+    """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, error: Optional[str], messages: Optional[List[DataMessage]], result: Any, usage: Optional[IndigoUsage], message: Optional[str], token: Optional[str], meta: Optional[Dict[str, Any]], text: Optional[str], type: Optional[Type24], function_name: Optional[str], reason: Any, input_tokens_used: Optional[float], model: Optional[str], output_tokens_used: Optional[float]) -> None:
-        self.error = error
-        self.messages = messages
-        self.result = result
-        self.usage = usage
-        self.message = message
-        self.token = token
+    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: str, file_id: Optional[str], id: str, instruction: str, meta: Optional[Dict[str, Any]], name: str, secret_id: Optional[str], space_id: Optional[str], updated_at: float) -> None:
+        self.blueprint_id = blueprint_id
+        self.bot_id = bot_id
+        self.created_at = created_at
+        self.description = description
+        self.file_id = file_id
+        self.id = id
+        self.instruction = instruction
         self.meta = meta
-        self.text = text
-        self.type = type
-        self.function_name = function_name
-        self.reason = reason
-        self.input_tokens_used = input_tokens_used
-        self.model = model
-        self.output_tokens_used = output_tokens_used
+        self.name = name
+        self.secret_id = secret_id
+        self.space_id = space_id
+        self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteStreamItemData':
+    def from_dict(obj: Any) -> 'SkillsetAbilitiesExportStreamItemData':
         assert isinstance(obj, dict)
-        error = from_union([from_str, from_none], obj.get("error"))
-        messages = from_union([lambda x: from_list(DataMessage.from_dict, x), from_none], obj.get("messages"))
-        result = obj.get("result")
-        usage = from_union([IndigoUsage.from_dict, from_none], obj.get("usage"))
-        message = from_union([from_str, from_none], obj.get("message"))
-        token = from_union([from_str, from_none], obj.get("token"))
-        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        text = from_union([from_str, from_none], obj.get("text"))
-        type = from_union([Type24, from_none], obj.get("type"))
-        function_name = from_union([from_str, from_none], obj.get("functionName"))
-        reason = obj.get("reason")
-        input_tokens_used = from_union([from_float, from_none], obj.get("inputTokensUsed"))
-        model = from_union([from_str, from_none], obj.get("model"))
-        output_tokens_used = from_union([from_float, from_none], obj.get("outputTokensUsed"))
-        return SkillsetAbilityExecuteStreamItemData(error, messages, result, usage, message, token, meta, text, type, function_name, reason, input_tokens_used, model, output_tokens_used)
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        created_at = from_float(obj.get("createdAt"))
+        description = from_str(obj.get("description"))
+        file_id = from_union([from_str, from_none], obj.get("fileId"))
+        id = from_str(obj.get("id"))
+        instruction = from_str(obj.get("instruction"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_str(obj.get("name"))
+        secret_id = from_union([from_str, from_none], obj.get("secretId"))
+        space_id = from_union([from_str, from_none], obj.get("spaceId"))
+        updated_at = from_float(obj.get("updatedAt"))
+        return SkillsetAbilitiesExportStreamItemData(blueprint_id, bot_id, created_at, description, file_id, id, instruction, meta, name, secret_id, space_id, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.error is not None:
-            result["error"] = from_union([from_str, from_none], self.error)
-        if self.messages is not None:
-            result["messages"] = from_union([lambda x: from_list(lambda x: to_class(DataMessage, x), x), from_none], self.messages)
-        if self.result is not None:
-            result["result"] = self.result
-        if self.usage is not None:
-            result["usage"] = from_union([lambda x: to_class(IndigoUsage, x), from_none], self.usage)
-        if self.message is not None:
-            result["message"] = from_union([from_str, from_none], self.message)
-        if self.token is not None:
-            result["token"] = from_union([from_str, from_none], self.token)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.bot_id is not None:
+            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        result["createdAt"] = to_float(self.created_at)
+        result["description"] = from_str(self.description)
+        if self.file_id is not None:
+            result["fileId"] = from_union([from_str, from_none], self.file_id)
+        result["id"] = from_str(self.id)
+        result["instruction"] = from_str(self.instruction)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        if self.text is not None:
-            result["text"] = from_union([from_str, from_none], self.text)
-        if self.type is not None:
-            result["type"] = from_union([lambda x: to_enum(Type24, x), from_none], self.type)
-        if self.function_name is not None:
-            result["functionName"] = from_union([from_str, from_none], self.function_name)
-        if self.reason is not None:
-            result["reason"] = self.reason
-        if self.input_tokens_used is not None:
-            result["inputTokensUsed"] = from_union([to_float, from_none], self.input_tokens_used)
-        if self.model is not None:
-            result["model"] = from_union([from_str, from_none], self.model)
-        if self.output_tokens_used is not None:
-            result["outputTokensUsed"] = from_union([to_float, from_none], self.output_tokens_used)
+        result["name"] = from_str(self.name)
+        if self.secret_id is not None:
+            result["secretId"] = from_union([from_str, from_none], self.secret_id)
+        if self.space_id is not None:
+            result["spaceId"] = from_union([from_str, from_none], self.space_id)
+        result["updatedAt"] = to_float(self.updated_at)
         return result
 
 
-class SkillsetAbilityExecuteStreamItemType(Enum):
+class SkillsetAbilitiesExportStreamItemType(Enum):
     """The type of event"""
 
-    ABORT = "abort"
-    COMPLETE_BEGIN = "completeBegin"
-    COMPLETE_END = "completeEnd"
-    ERROR = "error"
-    MESSAGE = "message"
-    REASONING_TOKEN = "reasoningToken"
-    RESULT = "result"
-    TOKEN = "token"
-    USAGE = "usage"
-    WAIT_FOR_CHANNEL_MESSAGE_BEGIN = "waitForChannelMessageBegin"
-    WAIT_FOR_CHANNEL_MESSAGE_END = "waitForChannelMessageEnd"
+    ITEM = "item"
 
 
-class SkillsetAbilityExecuteStreamItem:
-    data: SkillsetAbilityExecuteStreamItemData
-    """The data for the event
-    
-    A message in the conversation
-    
-    Information about an abort event in a streamed response
-    """
-    type: SkillsetAbilityExecuteStreamItemType
+class SkillsetAbilitiesExportStreamItem:
+    data: SkillsetAbilitiesExportStreamItemData
+    """Blueprint properties"""
+
+    type: SkillsetAbilitiesExportStreamItemType
     """The type of event"""
 
-    def __init__(self, data: SkillsetAbilityExecuteStreamItemData, type: SkillsetAbilityExecuteStreamItemType) -> None:
+    def __init__(self, data: SkillsetAbilitiesExportStreamItemData, type: SkillsetAbilitiesExportStreamItemType) -> None:
         self.data = data
         self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityExecuteStreamItem':
+    def from_dict(obj: Any) -> 'SkillsetAbilitiesExportStreamItem':
         assert isinstance(obj, dict)
-        data = SkillsetAbilityExecuteStreamItemData.from_dict(obj.get("data"))
-        type = SkillsetAbilityExecuteStreamItemType(obj.get("type"))
-        return SkillsetAbilityExecuteStreamItem(data, type)
+        data = SkillsetAbilitiesExportStreamItemData.from_dict(obj.get("data"))
+        type = SkillsetAbilitiesExportStreamItemType(obj.get("type"))
+        return SkillsetAbilitiesExportStreamItem(data, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["data"] = to_class(SkillsetAbilityExecuteStreamItemData, self.data)
-        result["type"] = to_enum(SkillsetAbilityExecuteStreamItemType, self.type)
+        result["data"] = to_class(SkillsetAbilitiesExportStreamItemData, self.data)
+        result["type"] = to_enum(SkillsetAbilitiesExportStreamItemType, self.type)
         return result
 
 
-class SkillsetAbilityFetchParams:
-    ability_id: str
-    """The ID of the ability to retrieve"""
+class SkillsetAbilityListParamsOrder(Enum):
+    """The order of the paginated items"""
+
+    ASC = "asc"
+    DESC = "desc"
+
+
+class SkillsetAbilityListParams:
+    cursor: Optional[str]
+    """The cursor to use for pagination"""
+
+    order: Optional[SkillsetAbilityListParamsOrder]
+    """The order of the paginated items"""
 
     skillset_id: str
     """The ID of the skillset"""
 
-    def __init__(self, ability_id: str, skillset_id: str) -> None:
-        self.ability_id = ability_id
+    take: Optional[int]
+    """The number of items to retrieve"""
+
+    def __init__(self, cursor: Optional[str], order: Optional[SkillsetAbilityListParamsOrder], skillset_id: str, take: Optional[int]) -> None:
+        self.cursor = cursor
+        self.order = order
         self.skillset_id = skillset_id
+        self.take = take
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityFetchParams':
+    def from_dict(obj: Any) -> 'SkillsetAbilityListParams':
         assert isinstance(obj, dict)
-        ability_id = from_str(obj.get("abilityId"))
+        cursor = from_union([from_str, from_none], obj.get("cursor"))
+        order = from_union([SkillsetAbilityListParamsOrder, from_none], obj.get("order"))
         skillset_id = from_str(obj.get("skillsetId"))
-        return SkillsetAbilityFetchParams(ability_id, skillset_id)
+        take = from_union([from_int, from_none], obj.get("take"))
+        return SkillsetAbilityListParams(cursor, order, skillset_id, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["abilityId"] = from_str(self.ability_id)
+        if self.cursor is not None:
+            result["cursor"] = from_union([from_str, from_none], self.cursor)
+        if self.order is not None:
+            result["order"] = from_union([lambda x: to_enum(SkillsetAbilityListParamsOrder, x), from_none], self.order)
         result["skillsetId"] = from_str(self.skillset_id)
+        if self.take is not None:
+            result["take"] = from_union([from_int, from_none], self.take)
         return result
 
 
-class SkillsetAbilityFetchResponse:
+class SkillsetAbilityListResponseItem:
     """Blueprint properties"""
 
     blueprint_id: Optional[str]
@@ -43031,8 +45211,6 @@ class SkillsetAbilityFetchResponse:
     """The instance ID"""
 
     instruction: str
-    """The instruction of the skillset ability"""
-
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
@@ -43063,7 +45241,7 @@ def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], created_a
         self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityFetchResponse':
+    def from_dict(obj: Any) -> 'SkillsetAbilityListResponseItem':
         assert isinstance(obj, dict)
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
@@ -43077,7 +45255,7 @@ def from_dict(obj: Any) -> 'SkillsetAbilityFetchResponse':
         secret_id = from_union([from_str, from_none], obj.get("secretId"))
         space_id = from_union([from_str, from_none], obj.get("spaceId"))
         updated_at = from_float(obj.get("updatedAt"))
-        return SkillsetAbilityFetchResponse(blueprint_id, bot_id, created_at, description, file_id, id, instruction, meta, name, secret_id, space_id, updated_at)
+        return SkillsetAbilityListResponseItem(blueprint_id, bot_id, created_at, description, file_id, id, instruction, meta, name, secret_id, space_id, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -43102,29 +45280,31 @@ def to_dict(self) -> dict:
         return result
 
 
-class SkillsetAbilityUpdateParams:
-    ability_id: str
-    skillset_id: str
+class SkillsetAbilityListResponse:
+    cursor: str
+    """Cursor for fetching the next page"""
 
-    def __init__(self, ability_id: str, skillset_id: str) -> None:
-        self.ability_id = ability_id
-        self.skillset_id = skillset_id
+    items: List[SkillsetAbilityListResponseItem]
+
+    def __init__(self, cursor: str, items: List[SkillsetAbilityListResponseItem]) -> None:
+        self.cursor = cursor
+        self.items = items
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityUpdateParams':
+    def from_dict(obj: Any) -> 'SkillsetAbilityListResponse':
         assert isinstance(obj, dict)
-        ability_id = from_str(obj.get("abilityId"))
-        skillset_id = from_str(obj.get("skillsetId"))
-        return SkillsetAbilityUpdateParams(ability_id, skillset_id)
+        cursor = from_str(obj.get("cursor"))
+        items = from_list(SkillsetAbilityListResponseItem.from_dict, obj.get("items"))
+        return SkillsetAbilityListResponse(cursor, items)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["abilityId"] = from_str(self.ability_id)
-        result["skillsetId"] = from_str(self.skillset_id)
+        result["cursor"] = from_str(self.cursor)
+        result["items"] = from_list(lambda x: to_class(SkillsetAbilityListResponseItem, x), self.items)
         return result
 
 
-class SkillsetAbilityUpdateRequest:
+class SkillsetAbilityListStreamItemData:
     """Blueprint properties"""
 
     blueprint_id: Optional[str]
@@ -43133,19 +45313,23 @@ class SkillsetAbilityUpdateRequest:
     bot_id: Optional[str]
     """The ID of the bot associated with the ability"""
 
-    description: Optional[str]
+    created_at: float
+    """The timestamp (ms) when the instance was created"""
+
+    description: str
     """The associated description"""
 
     file_id: Optional[str]
     """The ID of the file associated with the ability"""
 
-    instruction: Optional[str]
-    """The text to update the ability with"""
+    id: str
+    """The instance ID"""
 
+    instruction: str
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
-    name: Optional[str]
+    name: str
     """The associated name"""
 
     secret_id: Optional[str]
@@ -43154,30 +45338,39 @@ class SkillsetAbilityUpdateRequest:
     space_id: Optional[str]
     """The ID of the space associated with the ability"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], file_id: Optional[str], instruction: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], secret_id: Optional[str], space_id: Optional[str]) -> None:
+    updated_at: float
+    """The timestamp (ms) when the instance was updated"""
+
+    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: str, file_id: Optional[str], id: str, instruction: str, meta: Optional[Dict[str, Any]], name: str, secret_id: Optional[str], space_id: Optional[str], updated_at: float) -> None:
         self.blueprint_id = blueprint_id
         self.bot_id = bot_id
+        self.created_at = created_at
         self.description = description
         self.file_id = file_id
+        self.id = id
         self.instruction = instruction
         self.meta = meta
         self.name = name
         self.secret_id = secret_id
         self.space_id = space_id
+        self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityUpdateRequest':
+    def from_dict(obj: Any) -> 'SkillsetAbilityListStreamItemData':
         assert isinstance(obj, dict)
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         bot_id = from_union([from_str, from_none], obj.get("botId"))
-        description = from_union([from_str, from_none], obj.get("description"))
+        created_at = from_float(obj.get("createdAt"))
+        description = from_str(obj.get("description"))
         file_id = from_union([from_str, from_none], obj.get("fileId"))
-        instruction = from_union([from_str, from_none], obj.get("instruction"))
+        id = from_str(obj.get("id"))
+        instruction = from_str(obj.get("instruction"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        name = from_union([from_str, from_none], obj.get("name"))
+        name = from_str(obj.get("name"))
         secret_id = from_union([from_str, from_none], obj.get("secretId"))
         space_id = from_union([from_str, from_none], obj.get("spaceId"))
-        return SkillsetAbilityUpdateRequest(blueprint_id, bot_id, description, file_id, instruction, meta, name, secret_id, space_id)
+        updated_at = from_float(obj.get("updatedAt"))
+        return SkillsetAbilityListStreamItemData(blueprint_id, bot_id, created_at, description, file_id, id, instruction, meta, name, secret_id, space_id, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -43185,35 +45378,85 @@ def to_dict(self) -> dict:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.bot_id is not None:
             result["botId"] = from_union([from_str, from_none], self.bot_id)
-        if self.description is not None:
-            result["description"] = from_union([from_str, from_none], self.description)
+        result["createdAt"] = to_float(self.created_at)
+        result["description"] = from_str(self.description)
         if self.file_id is not None:
             result["fileId"] = from_union([from_str, from_none], self.file_id)
-        if self.instruction is not None:
-            result["instruction"] = from_union([from_str, from_none], self.instruction)
+        result["id"] = from_str(self.id)
+        result["instruction"] = from_str(self.instruction)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        if self.name is not None:
-            result["name"] = from_union([from_str, from_none], self.name)
+        result["name"] = from_str(self.name)
         if self.secret_id is not None:
             result["secretId"] = from_union([from_str, from_none], self.secret_id)
         if self.space_id is not None:
             result["spaceId"] = from_union([from_str, from_none], self.space_id)
+        result["updatedAt"] = to_float(self.updated_at)
         return result
 
 
-class SkillsetAbilityUpdateResponse:
+class SkillsetAbilityListStreamItemType(Enum):
+    """The type of event"""
+
+    ITEM = "item"
+
+
+class SkillsetAbilityListStreamItem:
+    data: SkillsetAbilityListStreamItemData
+    """Blueprint properties"""
+
+    type: SkillsetAbilityListStreamItemType
+    """The type of event"""
+
+    def __init__(self, data: SkillsetAbilityListStreamItemData, type: SkillsetAbilityListStreamItemType) -> None:
+        self.data = data
+        self.type = type
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SkillsetAbilityListStreamItem':
+        assert isinstance(obj, dict)
+        data = SkillsetAbilityListStreamItemData.from_dict(obj.get("data"))
+        type = SkillsetAbilityListStreamItemType(obj.get("type"))
+        return SkillsetAbilityListStreamItem(data, type)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["data"] = to_class(SkillsetAbilityListStreamItemData, self.data)
+        result["type"] = to_enum(SkillsetAbilityListStreamItemType, self.type)
+        return result
+
+
+class SkillsetDeleteParams:
+    skillset_id: str
+    """The ID of the skillset to delete"""
+
+    def __init__(self, skillset_id: str) -> None:
+        self.skillset_id = skillset_id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SkillsetDeleteParams':
+        assert isinstance(obj, dict)
+        skillset_id = from_str(obj.get("skillsetId"))
+        return SkillsetDeleteParams(skillset_id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["skillsetId"] = from_str(self.skillset_id)
+        return result
+
+
+class SkillsetDeleteResponse:
     id: str
-    """The ID of the updated ability"""
+    """The ID of the deleted skillset"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityUpdateResponse':
+    def from_dict(obj: Any) -> 'SkillsetDeleteResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return SkillsetAbilityUpdateResponse(id)
+        return SkillsetDeleteResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -43221,17 +45464,18 @@ def to_dict(self) -> dict:
         return result
 
 
-class SkillsetAbilityCreateParams:
+class SkillsetFetchParams:
     skillset_id: str
+    """The ID of the skillset to retrieve"""
 
     def __init__(self, skillset_id: str) -> None:
         self.skillset_id = skillset_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityCreateParams':
+    def from_dict(obj: Any) -> 'SkillsetFetchParams':
         assert isinstance(obj, dict)
         skillset_id = from_str(obj.get("skillsetId"))
-        return SkillsetAbilityCreateParams(skillset_id)
+        return SkillsetFetchParams(skillset_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -43239,23 +45483,31 @@ def to_dict(self) -> dict:
         return result
 
 
-class SkillsetAbilityCreateRequest:
+class SkillsetFetchResponseVisibility(Enum):
+    """The skillset visibility"""
+
+    PRIVATE = "private"
+    PROTECTED = "protected"
+    PUBLIC = "public"
+
+
+class SkillsetFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: Optional[str]
-    """The ID of the bot associated with the ability"""
+    created_at: float
+    """The timestamp (ms) when the instance was created"""
 
     description: Optional[str]
     """The associated description"""
 
-    file_id: Optional[str]
-    """The ID of the file associated with the ability"""
-
-    instruction: Optional[str]
-    """The instruction of the ability"""
+    id: str
+    """The instance ID"""
 
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
@@ -43263,72 +45515,236 @@ class SkillsetAbilityCreateRequest:
     name: Optional[str]
     """The associated name"""
 
-    secret_id: Optional[str]
-    """The ID of the secret associated with the ability"""
+    updated_at: float
+    """The timestamp (ms) when the instance was updated"""
 
-    space_id: Optional[str]
-    """The ID of the space associated with the ability"""
+    visibility: Optional[SkillsetFetchResponseVisibility]
+    """The skillset visibility"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], description: Optional[str], file_id: Optional[str], instruction: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], secret_id: Optional[str], space_id: Optional[str]) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[SkillsetFetchResponseVisibility]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
-        self.bot_id = bot_id
+        self.created_at = created_at
         self.description = description
-        self.file_id = file_id
-        self.instruction = instruction
+        self.id = id
         self.meta = meta
         self.name = name
-        self.secret_id = secret_id
-        self.space_id = space_id
+        self.updated_at = updated_at
+        self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityCreateRequest':
+    def from_dict(obj: Any) -> 'SkillsetFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
-        file_id = from_union([from_str, from_none], obj.get("fileId"))
-        instruction = from_union([from_str, from_none], obj.get("instruction"))
+        id = from_str(obj.get("id"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        secret_id = from_union([from_str, from_none], obj.get("secretId"))
-        space_id = from_union([from_str, from_none], obj.get("spaceId"))
-        return SkillsetAbilityCreateRequest(blueprint_id, bot_id, description, file_id, instruction, meta, name, secret_id, space_id)
+        updated_at = from_float(obj.get("updatedAt"))
+        visibility = from_union([SkillsetFetchResponseVisibility, from_none], obj.get("visibility"))
+        return SkillsetFetchResponse(alias, blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
-        if self.file_id is not None:
-            result["fileId"] = from_union([from_str, from_none], self.file_id)
-        if self.instruction is not None:
-            result["instruction"] = from_union([from_str, from_none], self.instruction)
+        result["id"] = from_str(self.id)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.secret_id is not None:
-            result["secretId"] = from_union([from_str, from_none], self.secret_id)
-        if self.space_id is not None:
-            result["spaceId"] = from_union([from_str, from_none], self.space_id)
+        result["updatedAt"] = to_float(self.updated_at)
+        if self.visibility is not None:
+            result["visibility"] = from_union([lambda x: to_enum(SkillsetFetchResponseVisibility, x), from_none], self.visibility)
+        return result
+
+
+class SkillsetUpdateParams:
+    skillset_id: str
+
+    def __init__(self, skillset_id: str) -> None:
+        self.skillset_id = skillset_id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SkillsetUpdateParams':
+        assert isinstance(obj, dict)
+        skillset_id = from_str(obj.get("skillsetId"))
+        return SkillsetUpdateParams(skillset_id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["skillsetId"] = from_str(self.skillset_id)
+        return result
+
+
+class SkillsetUpdateRequestVisibility(Enum):
+    """The skillset visibility"""
+
+    PRIVATE = "private"
+    PROTECTED = "protected"
+    PUBLIC = "public"
+
+
+class SkillsetUpdateRequest:
+    """Blueprint properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    visibility: Optional[SkillsetUpdateRequestVisibility]
+    """The skillset visibility"""
+
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], visibility: Optional[SkillsetUpdateRequestVisibility]) -> None:
+        self.alias = alias
+        self.blueprint_id = blueprint_id
+        self.description = description
+        self.meta = meta
+        self.name = name
+        self.visibility = visibility
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SkillsetUpdateRequest':
+        assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        visibility = from_union([SkillsetUpdateRequestVisibility, from_none], obj.get("visibility"))
+        return SkillsetUpdateRequest(alias, blueprint_id, description, meta, name, visibility)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.visibility is not None:
+            result["visibility"] = from_union([lambda x: to_enum(SkillsetUpdateRequestVisibility, x), from_none], self.visibility)
+        return result
+
+
+class SkillsetUpdateResponse:
+    id: str
+    """The ID of the updated skillset"""
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SkillsetUpdateResponse':
+        assert isinstance(obj, dict)
+        id = from_str(obj.get("id"))
+        return SkillsetUpdateResponse(id)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["id"] = from_str(self.id)
+        return result
+
+
+class SkillsetCreateRequestVisibility(Enum):
+    """The skillset visibility"""
+
+    PRIVATE = "private"
+    PROTECTED = "protected"
+    PUBLIC = "public"
+
+
+class SkillsetCreateRequest:
+    """Blueprint properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    visibility: Optional[SkillsetCreateRequestVisibility]
+    """The skillset visibility"""
+
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], visibility: Optional[SkillsetCreateRequestVisibility]) -> None:
+        self.alias = alias
+        self.blueprint_id = blueprint_id
+        self.description = description
+        self.meta = meta
+        self.name = name
+        self.visibility = visibility
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SkillsetCreateRequest':
+        assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        visibility = from_union([SkillsetCreateRequestVisibility, from_none], obj.get("visibility"))
+        return SkillsetCreateRequest(alias, blueprint_id, description, meta, name, visibility)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        if self.visibility is not None:
+            result["visibility"] = from_union([lambda x: to_enum(SkillsetCreateRequestVisibility, x), from_none], self.visibility)
         return result
 
 
-class SkillsetAbilityCreateResponse:
+class SkillsetCreateResponse:
     id: str
-    """The ID of the created ability"""
+    """The ID of the created skillset"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityCreateResponse':
+    def from_dict(obj: Any) -> 'SkillsetCreateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return SkillsetAbilityCreateResponse(id)
+        return SkillsetCreateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -43336,605 +45752,443 @@ def to_dict(self) -> dict:
         return result
 
 
-class SkillsetAbilitiesExportParamsOrder(Enum):
+class SkillsetListParamsOrder(Enum):
     """The order of the paginated items"""
 
     ASC = "asc"
     DESC = "desc"
 
 
-class SkillsetAbilitiesExportParams:
+class SkillsetListParams:
     cursor: Optional[str]
     """The cursor to use for pagination"""
 
-    order: Optional[SkillsetAbilitiesExportParamsOrder]
-    """The order of the paginated items"""
+    meta: Optional[Dict[str, str]]
+    """Key-value pairs to filter the partner users by metadata"""
 
-    skillset_id: str
-    """The ID of the skillset to export"""
+    order: Optional[SkillsetListParamsOrder]
+    """The order of the paginated items"""
 
     take: Optional[int]
     """The number of items to retrieve"""
 
-    def __init__(self, cursor: Optional[str], order: Optional[SkillsetAbilitiesExportParamsOrder], skillset_id: str, take: Optional[int]) -> None:
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[SkillsetListParamsOrder], take: Optional[int]) -> None:
         self.cursor = cursor
+        self.meta = meta
         self.order = order
-        self.skillset_id = skillset_id
         self.take = take
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilitiesExportParams':
+    def from_dict(obj: Any) -> 'SkillsetListParams':
         assert isinstance(obj, dict)
         cursor = from_union([from_str, from_none], obj.get("cursor"))
-        order = from_union([SkillsetAbilitiesExportParamsOrder, from_none], obj.get("order"))
-        skillset_id = from_str(obj.get("skillsetId"))
+        meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
+        order = from_union([SkillsetListParamsOrder, from_none], obj.get("order"))
         take = from_union([from_int, from_none], obj.get("take"))
-        return SkillsetAbilitiesExportParams(cursor, order, skillset_id, take)
+        return SkillsetListParams(cursor, meta, order, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.cursor is not None:
             result["cursor"] = from_union([from_str, from_none], self.cursor)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
         if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(SkillsetAbilitiesExportParamsOrder, x), from_none], self.order)
-        result["skillsetId"] = from_str(self.skillset_id)
+            result["order"] = from_union([lambda x: to_enum(SkillsetListParamsOrder, x), from_none], self.order)
         if self.take is not None:
             result["take"] = from_union([from_int, from_none], self.take)
         return result
 
 
-class SkillsetAbilitiesExportResponseItem:
+class BraggadociousVisibility(Enum):
+    """The skillset visibility"""
+
+    PRIVATE = "private"
+    PROTECTED = "protected"
+    PUBLIC = "public"
+
+
+class SkillsetListResponseItem:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: Optional[str]
-    """The ID of the bot associated with the ability"""
-
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
-    description: str
+    description: Optional[str]
     """The associated description"""
 
-    file_id: Optional[str]
-    """The ID of the file associated with the ability"""
-
     id: str
     """The instance ID"""
 
-    instruction: str
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
-    name: str
+    name: Optional[str]
     """The associated name"""
 
-    secret_id: Optional[str]
-    """The ID of the secret associated with the ability"""
-
-    space_id: Optional[str]
-    """The ID of the space associated with the ability"""
-
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: str, file_id: Optional[str], id: str, instruction: str, meta: Optional[Dict[str, Any]], name: str, secret_id: Optional[str], space_id: Optional[str], updated_at: float) -> None:
+    visibility: Optional[BraggadociousVisibility]
+    """The skillset visibility"""
+
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[BraggadociousVisibility]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
-        self.bot_id = bot_id
         self.created_at = created_at
         self.description = description
-        self.file_id = file_id
         self.id = id
-        self.instruction = instruction
         self.meta = meta
         self.name = name
-        self.secret_id = secret_id
-        self.space_id = space_id
         self.updated_at = updated_at
+        self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilitiesExportResponseItem':
+    def from_dict(obj: Any) -> 'SkillsetListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
         created_at = from_float(obj.get("createdAt"))
-        description = from_str(obj.get("description"))
-        file_id = from_union([from_str, from_none], obj.get("fileId"))
+        description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
-        instruction = from_str(obj.get("instruction"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        name = from_str(obj.get("name"))
-        secret_id = from_union([from_str, from_none], obj.get("secretId"))
-        space_id = from_union([from_str, from_none], obj.get("spaceId"))
+        name = from_union([from_str, from_none], obj.get("name"))
         updated_at = from_float(obj.get("updatedAt"))
-        return SkillsetAbilitiesExportResponseItem(blueprint_id, bot_id, created_at, description, file_id, id, instruction, meta, name, secret_id, space_id, updated_at)
+        visibility = from_union([BraggadociousVisibility, from_none], obj.get("visibility"))
+        return SkillsetListResponseItem(alias, blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
         result["createdAt"] = to_float(self.created_at)
-        result["description"] = from_str(self.description)
-        if self.file_id is not None:
-            result["fileId"] = from_union([from_str, from_none], self.file_id)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
         result["id"] = from_str(self.id)
-        result["instruction"] = from_str(self.instruction)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        result["name"] = from_str(self.name)
-        if self.secret_id is not None:
-            result["secretId"] = from_union([from_str, from_none], self.secret_id)
-        if self.space_id is not None:
-            result["spaceId"] = from_union([from_str, from_none], self.space_id)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
         result["updatedAt"] = to_float(self.updated_at)
+        if self.visibility is not None:
+            result["visibility"] = from_union([lambda x: to_enum(BraggadociousVisibility, x), from_none], self.visibility)
         return result
 
 
-class SkillsetAbilitiesExportResponse:
+class SkillsetListResponse:
     cursor: str
     """Cursor for fetching the next page"""
 
-    items: List[SkillsetAbilitiesExportResponseItem]
+    items: List[SkillsetListResponseItem]
 
-    def __init__(self, cursor: str, items: List[SkillsetAbilitiesExportResponseItem]) -> None:
+    def __init__(self, cursor: str, items: List[SkillsetListResponseItem]) -> None:
         self.cursor = cursor
         self.items = items
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilitiesExportResponse':
+    def from_dict(obj: Any) -> 'SkillsetListResponse':
         assert isinstance(obj, dict)
         cursor = from_str(obj.get("cursor"))
-        items = from_list(SkillsetAbilitiesExportResponseItem.from_dict, obj.get("items"))
-        return SkillsetAbilitiesExportResponse(cursor, items)
+        items = from_list(SkillsetListResponseItem.from_dict, obj.get("items"))
+        return SkillsetListResponse(cursor, items)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["cursor"] = from_str(self.cursor)
-        result["items"] = from_list(lambda x: to_class(SkillsetAbilitiesExportResponseItem, x), self.items)
+        result["items"] = from_list(lambda x: to_class(SkillsetListResponseItem, x), self.items)
         return result
 
 
-class SkillsetAbilitiesExportStreamItemData:
+class Visibility1(Enum):
+    """The skillset visibility"""
+
+    PRIVATE = "private"
+    PROTECTED = "protected"
+    PUBLIC = "public"
+
+
+class SkillsetListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: Optional[str]
-    """The ID of the bot associated with the ability"""
-
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
-    description: str
+    description: Optional[str]
     """The associated description"""
 
-    file_id: Optional[str]
-    """The ID of the file associated with the ability"""
-
     id: str
     """The instance ID"""
 
-    instruction: str
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
-    name: str
+    name: Optional[str]
     """The associated name"""
 
-    secret_id: Optional[str]
-    """The ID of the secret associated with the ability"""
-
-    space_id: Optional[str]
-    """The ID of the space associated with the ability"""
-
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: str, file_id: Optional[str], id: str, instruction: str, meta: Optional[Dict[str, Any]], name: str, secret_id: Optional[str], space_id: Optional[str], updated_at: float) -> None:
+    visibility: Optional[Visibility1]
+    """The skillset visibility"""
+
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[Visibility1]) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
-        self.bot_id = bot_id
         self.created_at = created_at
         self.description = description
-        self.file_id = file_id
         self.id = id
-        self.instruction = instruction
         self.meta = meta
         self.name = name
-        self.secret_id = secret_id
-        self.space_id = space_id
         self.updated_at = updated_at
+        self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilitiesExportStreamItemData':
+    def from_dict(obj: Any) -> 'SkillsetListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
         created_at = from_float(obj.get("createdAt"))
-        description = from_str(obj.get("description"))
-        file_id = from_union([from_str, from_none], obj.get("fileId"))
+        description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
-        instruction = from_str(obj.get("instruction"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        name = from_str(obj.get("name"))
-        secret_id = from_union([from_str, from_none], obj.get("secretId"))
-        space_id = from_union([from_str, from_none], obj.get("spaceId"))
+        name = from_union([from_str, from_none], obj.get("name"))
         updated_at = from_float(obj.get("updatedAt"))
-        return SkillsetAbilitiesExportStreamItemData(blueprint_id, bot_id, created_at, description, file_id, id, instruction, meta, name, secret_id, space_id, updated_at)
+        visibility = from_union([Visibility1, from_none], obj.get("visibility"))
+        return SkillsetListStreamItemData(alias, blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
         result["createdAt"] = to_float(self.created_at)
-        result["description"] = from_str(self.description)
-        if self.file_id is not None:
-            result["fileId"] = from_union([from_str, from_none], self.file_id)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
         result["id"] = from_str(self.id)
-        result["instruction"] = from_str(self.instruction)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        result["name"] = from_str(self.name)
-        if self.secret_id is not None:
-            result["secretId"] = from_union([from_str, from_none], self.secret_id)
-        if self.space_id is not None:
-            result["spaceId"] = from_union([from_str, from_none], self.space_id)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
         result["updatedAt"] = to_float(self.updated_at)
+        if self.visibility is not None:
+            result["visibility"] = from_union([lambda x: to_enum(Visibility1, x), from_none], self.visibility)
         return result
 
 
-class SkillsetAbilitiesExportStreamItemType(Enum):
+class SkillsetListStreamItemType(Enum):
     """The type of event"""
 
     ITEM = "item"
 
 
-class SkillsetAbilitiesExportStreamItem:
-    data: SkillsetAbilitiesExportStreamItemData
+class SkillsetListStreamItem:
+    data: SkillsetListStreamItemData
     """Blueprint properties"""
 
-    type: SkillsetAbilitiesExportStreamItemType
+    type: SkillsetListStreamItemType
     """The type of event"""
 
-    def __init__(self, data: SkillsetAbilitiesExportStreamItemData, type: SkillsetAbilitiesExportStreamItemType) -> None:
+    def __init__(self, data: SkillsetListStreamItemData, type: SkillsetListStreamItemType) -> None:
         self.data = data
         self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilitiesExportStreamItem':
+    def from_dict(obj: Any) -> 'SkillsetListStreamItem':
         assert isinstance(obj, dict)
-        data = SkillsetAbilitiesExportStreamItemData.from_dict(obj.get("data"))
-        type = SkillsetAbilitiesExportStreamItemType(obj.get("type"))
-        return SkillsetAbilitiesExportStreamItem(data, type)
+        data = SkillsetListStreamItemData.from_dict(obj.get("data"))
+        type = SkillsetListStreamItemType(obj.get("type"))
+        return SkillsetListStreamItem(data, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["data"] = to_class(SkillsetAbilitiesExportStreamItemData, self.data)
-        result["type"] = to_enum(SkillsetAbilitiesExportStreamItemType, self.type)
+        result["data"] = to_class(SkillsetListStreamItemData, self.data)
+        result["type"] = to_enum(SkillsetListStreamItemType, self.type)
         return result
 
 
-class SkillsetAbilityListParamsOrder(Enum):
-    """The order of the paginated items"""
-
-    ASC = "asc"
-    DESC = "desc"
-
-
-class SkillsetAbilityListParams:
-    cursor: Optional[str]
-    """The cursor to use for pagination"""
-
-    order: Optional[SkillsetAbilityListParamsOrder]
-    """The order of the paginated items"""
-
-    skillset_id: str
-    """The ID of the skillset"""
-
-    take: Optional[int]
-    """The number of items to retrieve"""
+class SpaceDeleteParams:
+    space_id: str
+    """The ID of the space to delete"""
 
-    def __init__(self, cursor: Optional[str], order: Optional[SkillsetAbilityListParamsOrder], skillset_id: str, take: Optional[int]) -> None:
-        self.cursor = cursor
-        self.order = order
-        self.skillset_id = skillset_id
-        self.take = take
+    def __init__(self, space_id: str) -> None:
+        self.space_id = space_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityListParams':
+    def from_dict(obj: Any) -> 'SpaceDeleteParams':
         assert isinstance(obj, dict)
-        cursor = from_union([from_str, from_none], obj.get("cursor"))
-        order = from_union([SkillsetAbilityListParamsOrder, from_none], obj.get("order"))
-        skillset_id = from_str(obj.get("skillsetId"))
-        take = from_union([from_int, from_none], obj.get("take"))
-        return SkillsetAbilityListParams(cursor, order, skillset_id, take)
+        space_id = from_str(obj.get("spaceId"))
+        return SpaceDeleteParams(space_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.cursor is not None:
-            result["cursor"] = from_union([from_str, from_none], self.cursor)
-        if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(SkillsetAbilityListParamsOrder, x), from_none], self.order)
-        result["skillsetId"] = from_str(self.skillset_id)
-        if self.take is not None:
-            result["take"] = from_union([from_int, from_none], self.take)
+        result["spaceId"] = from_str(self.space_id)
         return result
 
 
-class SkillsetAbilityListResponseItem:
-    """Blueprint properties"""
-
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
-
-    bot_id: Optional[str]
-    """The ID of the bot associated with the ability"""
-
-    created_at: float
-    """The timestamp (ms) when the instance was created"""
-
-    description: str
-    """The associated description"""
-
-    file_id: Optional[str]
-    """The ID of the file associated with the ability"""
-
+class SpaceDeleteResponse:
     id: str
-    """The instance ID"""
-
-    instruction: str
-    meta: Optional[Dict[str, Any]]
-    """Meta data information"""
-
-    name: str
-    """The associated name"""
-
-    secret_id: Optional[str]
-    """The ID of the secret associated with the ability"""
-
-    space_id: Optional[str]
-    """The ID of the space associated with the ability"""
-
-    updated_at: float
-    """The timestamp (ms) when the instance was updated"""
+    """The ID of the deleted space"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: str, file_id: Optional[str], id: str, instruction: str, meta: Optional[Dict[str, Any]], name: str, secret_id: Optional[str], space_id: Optional[str], updated_at: float) -> None:
-        self.blueprint_id = blueprint_id
-        self.bot_id = bot_id
-        self.created_at = created_at
-        self.description = description
-        self.file_id = file_id
+    def __init__(self, id: str) -> None:
         self.id = id
-        self.instruction = instruction
-        self.meta = meta
-        self.name = name
-        self.secret_id = secret_id
-        self.space_id = space_id
-        self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityListResponseItem':
+    def from_dict(obj: Any) -> 'SpaceDeleteResponse':
         assert isinstance(obj, dict)
-        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
-        created_at = from_float(obj.get("createdAt"))
-        description = from_str(obj.get("description"))
-        file_id = from_union([from_str, from_none], obj.get("fileId"))
         id = from_str(obj.get("id"))
-        instruction = from_str(obj.get("instruction"))
-        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        name = from_str(obj.get("name"))
-        secret_id = from_union([from_str, from_none], obj.get("secretId"))
-        space_id = from_union([from_str, from_none], obj.get("spaceId"))
-        updated_at = from_float(obj.get("updatedAt"))
-        return SkillsetAbilityListResponseItem(blueprint_id, bot_id, created_at, description, file_id, id, instruction, meta, name, secret_id, space_id, updated_at)
+        return SpaceDeleteResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
-        result["createdAt"] = to_float(self.created_at)
-        result["description"] = from_str(self.description)
-        if self.file_id is not None:
-            result["fileId"] = from_union([from_str, from_none], self.file_id)
         result["id"] = from_str(self.id)
-        result["instruction"] = from_str(self.instruction)
-        if self.meta is not None:
-            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        result["name"] = from_str(self.name)
-        if self.secret_id is not None:
-            result["secretId"] = from_union([from_str, from_none], self.secret_id)
-        if self.space_id is not None:
-            result["spaceId"] = from_union([from_str, from_none], self.space_id)
-        result["updatedAt"] = to_float(self.updated_at)
         return result
 
 
-class SkillsetAbilityListResponse:
-    cursor: str
-    """Cursor for fetching the next page"""
-
-    items: List[SkillsetAbilityListResponseItem]
+class SpaceFetchParams:
+    space_id: str
+    """The ID of the space to retrieve"""
 
-    def __init__(self, cursor: str, items: List[SkillsetAbilityListResponseItem]) -> None:
-        self.cursor = cursor
-        self.items = items
+    def __init__(self, space_id: str) -> None:
+        self.space_id = space_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityListResponse':
+    def from_dict(obj: Any) -> 'SpaceFetchParams':
         assert isinstance(obj, dict)
-        cursor = from_str(obj.get("cursor"))
-        items = from_list(SkillsetAbilityListResponseItem.from_dict, obj.get("items"))
-        return SkillsetAbilityListResponse(cursor, items)
+        space_id = from_str(obj.get("spaceId"))
+        return SpaceFetchParams(space_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["cursor"] = from_str(self.cursor)
-        result["items"] = from_list(lambda x: to_class(SkillsetAbilityListResponseItem, x), self.items)
+        result["spaceId"] = from_str(self.space_id)
         return result
 
 
-class SkillsetAbilityListStreamItemData:
+class SpaceFetchResponse:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
-    bot_id: Optional[str]
-    """The ID of the bot associated with the ability"""
+    contact_id: Optional[str]
+    """The contact associated with the space"""
 
     created_at: float
     """The timestamp (ms) when the instance was created"""
 
-    description: str
+    description: Optional[str]
     """The associated description"""
 
-    file_id: Optional[str]
-    """The ID of the file associated with the ability"""
-
     id: str
     """The instance ID"""
 
-    instruction: str
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
-    name: str
+    name: Optional[str]
     """The associated name"""
 
-    secret_id: Optional[str]
-    """The ID of the secret associated with the ability"""
-
-    space_id: Optional[str]
-    """The ID of the space associated with the ability"""
-
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], bot_id: Optional[str], created_at: float, description: str, file_id: Optional[str], id: str, instruction: str, meta: Optional[Dict[str, Any]], name: str, secret_id: Optional[str], space_id: Optional[str], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], contact_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
-        self.bot_id = bot_id
+        self.contact_id = contact_id
         self.created_at = created_at
         self.description = description
-        self.file_id = file_id
         self.id = id
-        self.instruction = instruction
         self.meta = meta
         self.name = name
-        self.secret_id = secret_id
-        self.space_id = space_id
         self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityListStreamItemData':
+    def from_dict(obj: Any) -> 'SpaceFetchResponse':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        bot_id = from_union([from_str, from_none], obj.get("botId"))
+        contact_id = from_union([from_str, from_none], obj.get("contactId"))
         created_at = from_float(obj.get("createdAt"))
-        description = from_str(obj.get("description"))
-        file_id = from_union([from_str, from_none], obj.get("fileId"))
+        description = from_union([from_str, from_none], obj.get("description"))
         id = from_str(obj.get("id"))
-        instruction = from_str(obj.get("instruction"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        name = from_str(obj.get("name"))
-        secret_id = from_union([from_str, from_none], obj.get("secretId"))
-        space_id = from_union([from_str, from_none], obj.get("spaceId"))
+        name = from_union([from_str, from_none], obj.get("name"))
         updated_at = from_float(obj.get("updatedAt"))
-        return SkillsetAbilityListStreamItemData(blueprint_id, bot_id, created_at, description, file_id, id, instruction, meta, name, secret_id, space_id, updated_at)
+        return SpaceFetchResponse(alias, blueprint_id, contact_id, created_at, description, id, meta, name, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.bot_id is not None:
-            result["botId"] = from_union([from_str, from_none], self.bot_id)
+        if self.contact_id is not None:
+            result["contactId"] = from_union([from_str, from_none], self.contact_id)
         result["createdAt"] = to_float(self.created_at)
-        result["description"] = from_str(self.description)
-        if self.file_id is not None:
-            result["fileId"] = from_union([from_str, from_none], self.file_id)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
         result["id"] = from_str(self.id)
-        result["instruction"] = from_str(self.instruction)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        result["name"] = from_str(self.name)
-        if self.secret_id is not None:
-            result["secretId"] = from_union([from_str, from_none], self.secret_id)
-        if self.space_id is not None:
-            result["spaceId"] = from_union([from_str, from_none], self.space_id)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
         result["updatedAt"] = to_float(self.updated_at)
         return result
 
 
-class SkillsetAbilityListStreamItemType(Enum):
-    """The type of event"""
-
-    ITEM = "item"
-
-
-class SkillsetAbilityListStreamItem:
-    data: SkillsetAbilityListStreamItemData
-    """Blueprint properties"""
-
-    type: SkillsetAbilityListStreamItemType
-    """The type of event"""
-
-    def __init__(self, data: SkillsetAbilityListStreamItemData, type: SkillsetAbilityListStreamItemType) -> None:
-        self.data = data
-        self.type = type
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetAbilityListStreamItem':
-        assert isinstance(obj, dict)
-        data = SkillsetAbilityListStreamItemData.from_dict(obj.get("data"))
-        type = SkillsetAbilityListStreamItemType(obj.get("type"))
-        return SkillsetAbilityListStreamItem(data, type)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["data"] = to_class(SkillsetAbilityListStreamItemData, self.data)
-        result["type"] = to_enum(SkillsetAbilityListStreamItemType, self.type)
-        return result
-
+class SpaceSiteDeleteParams:
+    site_id: str
+    """The ID of the site to delete"""
 
-class SkillsetDeleteParams:
-    skillset_id: str
-    """The ID of the skillset to delete"""
+    space_id: str
 
-    def __init__(self, skillset_id: str) -> None:
-        self.skillset_id = skillset_id
+    def __init__(self, site_id: str, space_id: str) -> None:
+        self.site_id = site_id
+        self.space_id = space_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetDeleteParams':
+    def from_dict(obj: Any) -> 'SpaceSiteDeleteParams':
         assert isinstance(obj, dict)
-        skillset_id = from_str(obj.get("skillsetId"))
-        return SkillsetDeleteParams(skillset_id)
+        site_id = from_str(obj.get("siteId"))
+        space_id = from_str(obj.get("spaceId"))
+        return SpaceSiteDeleteParams(site_id, space_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["skillsetId"] = from_str(self.skillset_id)
+        result["siteId"] = from_str(self.site_id)
+        result["spaceId"] = from_str(self.space_id)
         return result
 
 
-class SkillsetDeleteResponse:
+class SpaceSiteDeleteResponse:
     id: str
-    """The ID of the deleted skillset"""
+    """The ID of the deleted site"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetDeleteResponse':
+    def from_dict(obj: Any) -> 'SpaceSiteDeleteResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return SkillsetDeleteResponse(id)
+        return SpaceSiteDeleteResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -43942,38 +46196,35 @@ def to_dict(self) -> dict:
         return result
 
 
-class SkillsetFetchParams:
-    skillset_id: str
-    """The ID of the skillset to retrieve"""
+class SpaceSiteFetchParams:
+    site_id: str
+    """The ID of the site to retrieve"""
 
-    def __init__(self, skillset_id: str) -> None:
-        self.skillset_id = skillset_id
+    space_id: str
+
+    def __init__(self, site_id: str, space_id: str) -> None:
+        self.site_id = site_id
+        self.space_id = space_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetFetchParams':
+    def from_dict(obj: Any) -> 'SpaceSiteFetchParams':
         assert isinstance(obj, dict)
-        skillset_id = from_str(obj.get("skillsetId"))
-        return SkillsetFetchParams(skillset_id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["skillsetId"] = from_str(self.skillset_id)
-        return result
-
-
-class SkillsetFetchResponseVisibility(Enum):
-    """The skillset visibility"""
-
-    PRIVATE = "private"
-    PROTECTED = "protected"
-    PUBLIC = "public"
+        site_id = from_str(obj.get("siteId"))
+        space_id = from_str(obj.get("spaceId"))
+        return SpaceSiteFetchParams(site_id, space_id)
 
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["siteId"] = from_str(self.site_id)
+        result["spaceId"] = from_str(self.space_id)
+        return result
 
-class SkillsetFetchResponse:
-    """Blueprint properties"""
 
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
+class SpaceSiteFetchResponse:
+    """Instance list properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
     created_at: float
     """The timestamp (ms) when the instance was created"""
@@ -43981,157 +46232,195 @@ class SkillsetFetchResponse:
     description: Optional[str]
     """The associated description"""
 
+    domain: Optional[str]
+    """The host the site is served at"""
+
     id: str
     """The instance ID"""
 
+    index: Optional[str]
+    """Directory index filename"""
+
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
+    not_found: Optional[str]
+    """Not found filename"""
+
+    prefix: Optional[str]
+    """The folder prefix inside the space"""
+
+    space_id: Optional[str]
+    """The space the site belongs to"""
+
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    visibility: Optional[SkillsetFetchResponseVisibility]
-    """The skillset visibility"""
-
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[SkillsetFetchResponseVisibility]) -> None:
-        self.blueprint_id = blueprint_id
+    def __init__(self, alias: Optional[str], created_at: float, description: Optional[str], domain: Optional[str], id: str, index: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], not_found: Optional[str], prefix: Optional[str], space_id: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.created_at = created_at
         self.description = description
+        self.domain = domain
         self.id = id
+        self.index = index
         self.meta = meta
         self.name = name
+        self.not_found = not_found
+        self.prefix = prefix
+        self.space_id = space_id
         self.updated_at = updated_at
-        self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetFetchResponse':
+    def from_dict(obj: Any) -> 'SpaceSiteFetchResponse':
         assert isinstance(obj, dict)
-        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
+        domain = from_union([from_str, from_none], obj.get("domain"))
         id = from_str(obj.get("id"))
+        index = from_union([from_str, from_none], obj.get("index"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
+        not_found = from_union([from_str, from_none], obj.get("notFound"))
+        prefix = from_union([from_str, from_none], obj.get("prefix"))
+        space_id = from_union([from_str, from_none], obj.get("spaceId"))
         updated_at = from_float(obj.get("updatedAt"))
-        visibility = from_union([SkillsetFetchResponseVisibility, from_none], obj.get("visibility"))
-        return SkillsetFetchResponse(blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
+        return SpaceSiteFetchResponse(alias, created_at, description, domain, id, index, meta, name, not_found, prefix, space_id, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
+        if self.domain is not None:
+            result["domain"] = from_union([from_str, from_none], self.domain)
         result["id"] = from_str(self.id)
+        if self.index is not None:
+            result["index"] = from_union([from_str, from_none], self.index)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.not_found is not None:
+            result["notFound"] = from_union([from_str, from_none], self.not_found)
+        if self.prefix is not None:
+            result["prefix"] = from_union([from_str, from_none], self.prefix)
+        if self.space_id is not None:
+            result["spaceId"] = from_union([from_str, from_none], self.space_id)
         result["updatedAt"] = to_float(self.updated_at)
-        if self.visibility is not None:
-            result["visibility"] = from_union([lambda x: to_enum(SkillsetFetchResponseVisibility, x), from_none], self.visibility)
         return result
 
 
-class SkillsetUpdateParams:
-    skillset_id: str
+class SpaceSiteUpdateParams:
+    site_id: str
+    space_id: str
 
-    def __init__(self, skillset_id: str) -> None:
-        self.skillset_id = skillset_id
+    def __init__(self, site_id: str, space_id: str) -> None:
+        self.site_id = site_id
+        self.space_id = space_id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetUpdateParams':
+    def from_dict(obj: Any) -> 'SpaceSiteUpdateParams':
         assert isinstance(obj, dict)
-        skillset_id = from_str(obj.get("skillsetId"))
-        return SkillsetUpdateParams(skillset_id)
+        site_id = from_str(obj.get("siteId"))
+        space_id = from_str(obj.get("spaceId"))
+        return SpaceSiteUpdateParams(site_id, space_id)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        result["skillsetId"] = from_str(self.skillset_id)
+        result["siteId"] = from_str(self.site_id)
+        result["spaceId"] = from_str(self.space_id)
         return result
 
 
-class SkillsetUpdateRequestVisibility(Enum):
-    """The skillset visibility"""
-
-    PRIVATE = "private"
-    PROTECTED = "protected"
-    PUBLIC = "public"
-
-
-class SkillsetUpdateRequest:
-    """Blueprint properties"""
+class SpaceSiteUpdateRequest:
+    """Instance crud properties"""
 
     alias: Optional[str]
     """The unique alias for the instance"""
 
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
-
     description: Optional[str]
     """The associated description"""
 
+    domain: Optional[str]
+    """The host the site is served at (a <label>.chatbotkit.space subdomain)"""
+
+    index: Optional[str]
+    """Directory index filename"""
+
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    visibility: Optional[SkillsetUpdateRequestVisibility]
-    """The skillset visibility"""
+    not_found: Optional[str]
+    """Not found filename"""
 
-    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], visibility: Optional[SkillsetUpdateRequestVisibility]) -> None:
+    prefix: Optional[str]
+    """Optional folder prefix inside the space to serve from"""
+
+    def __init__(self, alias: Optional[str], description: Optional[str], domain: Optional[str], index: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], not_found: Optional[str], prefix: Optional[str]) -> None:
         self.alias = alias
-        self.blueprint_id = blueprint_id
         self.description = description
+        self.domain = domain
+        self.index = index
         self.meta = meta
         self.name = name
-        self.visibility = visibility
+        self.not_found = not_found
+        self.prefix = prefix
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetUpdateRequest':
+    def from_dict(obj: Any) -> 'SpaceSiteUpdateRequest':
         assert isinstance(obj, dict)
         alias = from_union([from_str, from_none], obj.get("alias"))
-        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         description = from_union([from_str, from_none], obj.get("description"))
+        domain = from_union([from_str, from_none], obj.get("domain"))
+        index = from_union([from_str, from_none], obj.get("index"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        visibility = from_union([SkillsetUpdateRequestVisibility, from_none], obj.get("visibility"))
-        return SkillsetUpdateRequest(alias, blueprint_id, description, meta, name, visibility)
+        not_found = from_union([from_str, from_none], obj.get("notFound"))
+        prefix = from_union([from_str, from_none], obj.get("prefix"))
+        return SpaceSiteUpdateRequest(alias, description, domain, index, meta, name, not_found, prefix)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.alias is not None:
             result["alias"] = from_union([from_str, from_none], self.alias)
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
+        if self.domain is not None:
+            result["domain"] = from_union([from_str, from_none], self.domain)
+        if self.index is not None:
+            result["index"] = from_union([from_str, from_none], self.index)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.visibility is not None:
-            result["visibility"] = from_union([lambda x: to_enum(SkillsetUpdateRequestVisibility, x), from_none], self.visibility)
+        if self.not_found is not None:
+            result["notFound"] = from_union([from_str, from_none], self.not_found)
+        if self.prefix is not None:
+            result["prefix"] = from_union([from_str, from_none], self.prefix)
         return result
 
 
-class SkillsetUpdateResponse:
+class SpaceSiteUpdateResponse:
     id: str
-    """The ID of the updated skillset"""
+    """The ID of the updated site"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetUpdateResponse':
+    def from_dict(obj: Any) -> 'SpaceSiteUpdateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return SkillsetUpdateResponse(id)
+        return SpaceSiteUpdateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -44139,83 +46428,106 @@ def to_dict(self) -> dict:
         return result
 
 
-class SkillsetCreateRequestVisibility(Enum):
-    """The skillset visibility"""
+class SpaceSiteCreateParams:
+    space_id: str
 
-    PRIVATE = "private"
-    PROTECTED = "protected"
-    PUBLIC = "public"
+    def __init__(self, space_id: str) -> None:
+        self.space_id = space_id
 
+    @staticmethod
+    def from_dict(obj: Any) -> 'SpaceSiteCreateParams':
+        assert isinstance(obj, dict)
+        space_id = from_str(obj.get("spaceId"))
+        return SpaceSiteCreateParams(space_id)
 
-class SkillsetCreateRequest:
-    """Blueprint properties"""
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["spaceId"] = from_str(self.space_id)
+        return result
+
+
+class SpaceSiteCreateRequest:
+    """Instance crud properties"""
 
     alias: Optional[str]
     """The unique alias for the instance"""
 
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
-
     description: Optional[str]
     """The associated description"""
 
+    domain: str
+    """The host the site is served at (a <label>.chatbotkit.space subdomain)"""
+
+    index: Optional[str]
+    """Directory index filename"""
+
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
-    visibility: Optional[SkillsetCreateRequestVisibility]
-    """The skillset visibility"""
+    not_found: Optional[str]
+    """Not found filename"""
 
-    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], description: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], visibility: Optional[SkillsetCreateRequestVisibility]) -> None:
+    prefix: Optional[str]
+    """Optional folder prefix inside the space to serve from"""
+
+    def __init__(self, alias: Optional[str], description: Optional[str], domain: str, index: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], not_found: Optional[str], prefix: Optional[str]) -> None:
         self.alias = alias
-        self.blueprint_id = blueprint_id
         self.description = description
+        self.domain = domain
+        self.index = index
         self.meta = meta
         self.name = name
-        self.visibility = visibility
+        self.not_found = not_found
+        self.prefix = prefix
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetCreateRequest':
+    def from_dict(obj: Any) -> 'SpaceSiteCreateRequest':
         assert isinstance(obj, dict)
         alias = from_union([from_str, from_none], obj.get("alias"))
-        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         description = from_union([from_str, from_none], obj.get("description"))
+        domain = from_str(obj.get("domain"))
+        index = from_union([from_str, from_none], obj.get("index"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
-        visibility = from_union([SkillsetCreateRequestVisibility, from_none], obj.get("visibility"))
-        return SkillsetCreateRequest(alias, blueprint_id, description, meta, name, visibility)
+        not_found = from_union([from_str, from_none], obj.get("notFound"))
+        prefix = from_union([from_str, from_none], obj.get("prefix"))
+        return SpaceSiteCreateRequest(alias, description, domain, index, meta, name, not_found, prefix)
 
     def to_dict(self) -> dict:
         result: dict = {}
         if self.alias is not None:
             result["alias"] = from_union([from_str, from_none], self.alias)
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
+        result["domain"] = from_str(self.domain)
+        if self.index is not None:
+            result["index"] = from_union([from_str, from_none], self.index)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
-        if self.visibility is not None:
-            result["visibility"] = from_union([lambda x: to_enum(SkillsetCreateRequestVisibility, x), from_none], self.visibility)
+        if self.not_found is not None:
+            result["notFound"] = from_union([from_str, from_none], self.not_found)
+        if self.prefix is not None:
+            result["prefix"] = from_union([from_str, from_none], self.prefix)
         return result
 
 
-class SkillsetCreateResponse:
+class SpaceSiteCreateResponse:
     id: str
-    """The ID of the created skillset"""
+    """The ID of the created site"""
 
     def __init__(self, id: str) -> None:
         self.id = id
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetCreateResponse':
+    def from_dict(obj: Any) -> 'SpaceSiteCreateResponse':
         assert isinstance(obj, dict)
         id = from_str(obj.get("id"))
-        return SkillsetCreateResponse(id)
+        return SpaceSiteCreateResponse(id)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -44223,40 +46535,43 @@ def to_dict(self) -> dict:
         return result
 
 
-class SkillsetListParamsOrder(Enum):
+class SpaceSiteListParamsOrder(Enum):
     """The order of the paginated items"""
 
     ASC = "asc"
     DESC = "desc"
 
 
-class SkillsetListParams:
+class SpaceSiteListParams:
     cursor: Optional[str]
     """The cursor to use for pagination"""
 
     meta: Optional[Dict[str, str]]
-    """Key-value pairs to filter the partner users by metadata"""
+    """Key-value pairs to filter the sites by metadata"""
 
-    order: Optional[SkillsetListParamsOrder]
+    order: Optional[SpaceSiteListParamsOrder]
     """The order of the paginated items"""
 
+    space_id: str
     take: Optional[int]
     """The number of items to retrieve"""
 
-    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[SkillsetListParamsOrder], take: Optional[int]) -> None:
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[SpaceSiteListParamsOrder], space_id: str, take: Optional[int]) -> None:
         self.cursor = cursor
         self.meta = meta
         self.order = order
+        self.space_id = space_id
         self.take = take
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetListParams':
+    def from_dict(obj: Any) -> 'SpaceSiteListParams':
         assert isinstance(obj, dict)
         cursor = from_union([from_str, from_none], obj.get("cursor"))
         meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
-        order = from_union([SkillsetListParamsOrder, from_none], obj.get("order"))
+        order = from_union([SpaceSiteListParamsOrder, from_none], obj.get("order"))
+        space_id = from_str(obj.get("spaceId"))
         take = from_union([from_int, from_none], obj.get("take"))
-        return SkillsetListParams(cursor, meta, order, take)
+        return SpaceSiteListParams(cursor, meta, order, space_id, take)
 
     def to_dict(self) -> dict:
         result: dict = {}
@@ -44265,25 +46580,18 @@ def to_dict(self) -> dict:
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
         if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(SkillsetListParamsOrder, x), from_none], self.order)
+            result["order"] = from_union([lambda x: to_enum(SpaceSiteListParamsOrder, x), from_none], self.order)
+        result["spaceId"] = from_str(self.space_id)
         if self.take is not None:
             result["take"] = from_union([from_int, from_none], self.take)
         return result
 
 
-class BraggadociousVisibility(Enum):
-    """The skillset visibility"""
-
-    PRIVATE = "private"
-    PROTECTED = "protected"
-    PUBLIC = "public"
-
-
-class SkillsetListResponseItem:
-    """Blueprint properties"""
+class SpaceSiteListResponseItem:
+    """Instance list properties"""
 
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
     created_at: float
     """The timestamp (ms) when the instance was created"""
@@ -44291,99 +46599,112 @@ class SkillsetListResponseItem:
     description: Optional[str]
     """The associated description"""
 
+    domain: Optional[str]
+    """The host the site is served at"""
+
     id: str
     """The instance ID"""
 
+    index: Optional[str]
+    """Directory index filename"""
+
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
+    not_found: Optional[str]
+    """Not found filename"""
+
+    prefix: Optional[str]
+    """The folder prefix inside the space"""
+
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    visibility: Optional[BraggadociousVisibility]
-    """The skillset visibility"""
-
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[BraggadociousVisibility]) -> None:
-        self.blueprint_id = blueprint_id
+    def __init__(self, alias: Optional[str], created_at: float, description: Optional[str], domain: Optional[str], id: str, index: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], not_found: Optional[str], prefix: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.created_at = created_at
         self.description = description
+        self.domain = domain
         self.id = id
+        self.index = index
         self.meta = meta
         self.name = name
+        self.not_found = not_found
+        self.prefix = prefix
         self.updated_at = updated_at
-        self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetListResponseItem':
+    def from_dict(obj: Any) -> 'SpaceSiteListResponseItem':
         assert isinstance(obj, dict)
-        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
+        domain = from_union([from_str, from_none], obj.get("domain"))
         id = from_str(obj.get("id"))
+        index = from_union([from_str, from_none], obj.get("index"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
+        not_found = from_union([from_str, from_none], obj.get("notFound"))
+        prefix = from_union([from_str, from_none], obj.get("prefix"))
         updated_at = from_float(obj.get("updatedAt"))
-        visibility = from_union([BraggadociousVisibility, from_none], obj.get("visibility"))
-        return SkillsetListResponseItem(blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
+        return SpaceSiteListResponseItem(alias, created_at, description, domain, id, index, meta, name, not_found, prefix, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
+        if self.domain is not None:
+            result["domain"] = from_union([from_str, from_none], self.domain)
         result["id"] = from_str(self.id)
+        if self.index is not None:
+            result["index"] = from_union([from_str, from_none], self.index)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.not_found is not None:
+            result["notFound"] = from_union([from_str, from_none], self.not_found)
+        if self.prefix is not None:
+            result["prefix"] = from_union([from_str, from_none], self.prefix)
         result["updatedAt"] = to_float(self.updated_at)
-        if self.visibility is not None:
-            result["visibility"] = from_union([lambda x: to_enum(BraggadociousVisibility, x), from_none], self.visibility)
         return result
 
 
-class SkillsetListResponse:
+class SpaceSiteListResponse:
     cursor: str
     """Cursor for fetching the next page"""
 
-    items: List[SkillsetListResponseItem]
+    items: List[SpaceSiteListResponseItem]
 
-    def __init__(self, cursor: str, items: List[SkillsetListResponseItem]) -> None:
+    def __init__(self, cursor: str, items: List[SpaceSiteListResponseItem]) -> None:
         self.cursor = cursor
         self.items = items
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetListResponse':
+    def from_dict(obj: Any) -> 'SpaceSiteListResponse':
         assert isinstance(obj, dict)
         cursor = from_str(obj.get("cursor"))
-        items = from_list(SkillsetListResponseItem.from_dict, obj.get("items"))
-        return SkillsetListResponse(cursor, items)
+        items = from_list(SpaceSiteListResponseItem.from_dict, obj.get("items"))
+        return SpaceSiteListResponse(cursor, items)
 
     def to_dict(self) -> dict:
         result: dict = {}
         result["cursor"] = from_str(self.cursor)
-        result["items"] = from_list(lambda x: to_class(SkillsetListResponseItem, x), self.items)
+        result["items"] = from_list(lambda x: to_class(SpaceSiteListResponseItem, x), self.items)
         return result
 
 
-class Visibility1(Enum):
-    """The skillset visibility"""
-
-    PRIVATE = "private"
-    PROTECTED = "protected"
-    PUBLIC = "public"
-
-
-class SkillsetListStreamItemData:
-    """Blueprint properties"""
+class SpaceSiteListStreamItemData:
+    """Instance list properties"""
 
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
+    alias: Optional[str]
+    """The unique alias for the instance"""
 
     created_at: float
     """The timestamp (ms) when the instance was created"""
@@ -44391,215 +46712,111 @@ class SkillsetListStreamItemData:
     description: Optional[str]
     """The associated description"""
 
+    domain: Optional[str]
+    """The host the site is served at"""
+
     id: str
     """The instance ID"""
 
+    index: Optional[str]
+    """Directory index filename"""
+
     meta: Optional[Dict[str, Any]]
     """Meta data information"""
 
     name: Optional[str]
     """The associated name"""
 
+    not_found: Optional[str]
+    """Not found filename"""
+
+    prefix: Optional[str]
+    """The folder prefix inside the space"""
+
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    visibility: Optional[Visibility1]
-    """The skillset visibility"""
-
-    def __init__(self, blueprint_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float, visibility: Optional[Visibility1]) -> None:
-        self.blueprint_id = blueprint_id
+    def __init__(self, alias: Optional[str], created_at: float, description: Optional[str], domain: Optional[str], id: str, index: Optional[str], meta: Optional[Dict[str, Any]], name: Optional[str], not_found: Optional[str], prefix: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.created_at = created_at
         self.description = description
+        self.domain = domain
         self.id = id
+        self.index = index
         self.meta = meta
         self.name = name
+        self.not_found = not_found
+        self.prefix = prefix
         self.updated_at = updated_at
-        self.visibility = visibility
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetListStreamItemData':
+    def from_dict(obj: Any) -> 'SpaceSiteListStreamItemData':
         assert isinstance(obj, dict)
-        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        alias = from_union([from_str, from_none], obj.get("alias"))
         created_at = from_float(obj.get("createdAt"))
         description = from_union([from_str, from_none], obj.get("description"))
+        domain = from_union([from_str, from_none], obj.get("domain"))
         id = from_str(obj.get("id"))
+        index = from_union([from_str, from_none], obj.get("index"))
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
+        not_found = from_union([from_str, from_none], obj.get("notFound"))
+        prefix = from_union([from_str, from_none], obj.get("prefix"))
         updated_at = from_float(obj.get("updatedAt"))
-        visibility = from_union([Visibility1, from_none], obj.get("visibility"))
-        return SkillsetListStreamItemData(blueprint_id, created_at, description, id, meta, name, updated_at, visibility)
+        return SpaceSiteListStreamItemData(alias, created_at, description, domain, id, index, meta, name, not_found, prefix, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         result["createdAt"] = to_float(self.created_at)
         if self.description is not None:
             result["description"] = from_union([from_str, from_none], self.description)
+        if self.domain is not None:
+            result["domain"] = from_union([from_str, from_none], self.domain)
         result["id"] = from_str(self.id)
+        if self.index is not None:
+            result["index"] = from_union([from_str, from_none], self.index)
         if self.meta is not None:
             result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
         if self.name is not None:
             result["name"] = from_union([from_str, from_none], self.name)
+        if self.not_found is not None:
+            result["notFound"] = from_union([from_str, from_none], self.not_found)
+        if self.prefix is not None:
+            result["prefix"] = from_union([from_str, from_none], self.prefix)
         result["updatedAt"] = to_float(self.updated_at)
-        if self.visibility is not None:
-            result["visibility"] = from_union([lambda x: to_enum(Visibility1, x), from_none], self.visibility)
         return result
 
 
-class SkillsetListStreamItemType(Enum):
+class SpaceSiteListStreamItemType(Enum):
     """The type of event"""
 
     ITEM = "item"
 
 
-class SkillsetListStreamItem:
-    data: SkillsetListStreamItemData
-    """Blueprint properties"""
+class SpaceSiteListStreamItem:
+    data: SpaceSiteListStreamItemData
+    """Instance list properties"""
 
-    type: SkillsetListStreamItemType
+    type: SpaceSiteListStreamItemType
     """The type of event"""
 
-    def __init__(self, data: SkillsetListStreamItemData, type: SkillsetListStreamItemType) -> None:
+    def __init__(self, data: SpaceSiteListStreamItemData, type: SpaceSiteListStreamItemType) -> None:
         self.data = data
         self.type = type
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SkillsetListStreamItem':
-        assert isinstance(obj, dict)
-        data = SkillsetListStreamItemData.from_dict(obj.get("data"))
-        type = SkillsetListStreamItemType(obj.get("type"))
-        return SkillsetListStreamItem(data, type)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["data"] = to_class(SkillsetListStreamItemData, self.data)
-        result["type"] = to_enum(SkillsetListStreamItemType, self.type)
-        return result
-
-
-class SpaceDeleteParams:
-    space_id: str
-    """The ID of the space to delete"""
-
-    def __init__(self, space_id: str) -> None:
-        self.space_id = space_id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'SpaceDeleteParams':
-        assert isinstance(obj, dict)
-        space_id = from_str(obj.get("spaceId"))
-        return SpaceDeleteParams(space_id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["spaceId"] = from_str(self.space_id)
-        return result
-
-
-class SpaceDeleteResponse:
-    id: str
-    """The ID of the deleted space"""
-
-    def __init__(self, id: str) -> None:
-        self.id = id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'SpaceDeleteResponse':
-        assert isinstance(obj, dict)
-        id = from_str(obj.get("id"))
-        return SpaceDeleteResponse(id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["id"] = from_str(self.id)
-        return result
-
-
-class SpaceFetchParams:
-    space_id: str
-    """The ID of the space to retrieve"""
-
-    def __init__(self, space_id: str) -> None:
-        self.space_id = space_id
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'SpaceFetchParams':
-        assert isinstance(obj, dict)
-        space_id = from_str(obj.get("spaceId"))
-        return SpaceFetchParams(space_id)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["spaceId"] = from_str(self.space_id)
-        return result
-
-
-class SpaceFetchResponse:
-    """Blueprint properties"""
-
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
-
-    contact_id: Optional[str]
-    """The contact associated with the space"""
-
-    created_at: float
-    """The timestamp (ms) when the instance was created"""
-
-    description: Optional[str]
-    """The associated description"""
-
-    id: str
-    """The instance ID"""
-
-    meta: Optional[Dict[str, Any]]
-    """Meta data information"""
-
-    name: Optional[str]
-    """The associated name"""
-
-    updated_at: float
-    """The timestamp (ms) when the instance was updated"""
-
-    def __init__(self, blueprint_id: Optional[str], contact_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float) -> None:
-        self.blueprint_id = blueprint_id
-        self.contact_id = contact_id
-        self.created_at = created_at
-        self.description = description
-        self.id = id
-        self.meta = meta
-        self.name = name
-        self.updated_at = updated_at
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'SpaceFetchResponse':
+    def from_dict(obj: Any) -> 'SpaceSiteListStreamItem':
         assert isinstance(obj, dict)
-        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        contact_id = from_union([from_str, from_none], obj.get("contactId"))
-        created_at = from_float(obj.get("createdAt"))
-        description = from_union([from_str, from_none], obj.get("description"))
-        id = from_str(obj.get("id"))
-        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        name = from_union([from_str, from_none], obj.get("name"))
-        updated_at = from_float(obj.get("updatedAt"))
-        return SpaceFetchResponse(blueprint_id, contact_id, created_at, description, id, meta, name, updated_at)
+        data = SpaceSiteListStreamItemData.from_dict(obj.get("data"))
+        type = SpaceSiteListStreamItemType(obj.get("type"))
+        return SpaceSiteListStreamItem(data, type)
 
     def to_dict(self) -> dict:
         result: dict = {}
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.contact_id is not None:
-            result["contactId"] = from_union([from_str, from_none], self.contact_id)
-        result["createdAt"] = to_float(self.created_at)
-        if self.description is not None:
-            result["description"] = from_union([from_str, from_none], self.description)
-        result["id"] = from_str(self.id)
-        if self.meta is not None:
-            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        if self.name is not None:
-            result["name"] = from_union([from_str, from_none], self.name)
-        result["updatedAt"] = to_float(self.updated_at)
+        result["data"] = to_class(SpaceSiteListStreamItemData, self.data)
+        result["type"] = to_enum(SpaceSiteListStreamItemType, self.type)
         return result
 
 
@@ -45441,155 +47658,160 @@ def __init__(self, blueprint_id: Optional[str], contact_id: Optional[str], creat
         self.updated_at = updated_at
 
     @staticmethod
-    def from_dict(obj: Any) -> 'SpacesExportStreamItemData':
-        assert isinstance(obj, dict)
-        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
-        contact_id = from_union([from_str, from_none], obj.get("contactId"))
-        created_at = from_float(obj.get("createdAt"))
-        description = from_union([from_str, from_none], obj.get("description"))
-        id = from_str(obj.get("id"))
-        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
-        name = from_union([from_str, from_none], obj.get("name"))
-        updated_at = from_float(obj.get("updatedAt"))
-        return SpacesExportStreamItemData(blueprint_id, contact_id, created_at, description, id, meta, name, updated_at)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        if self.blueprint_id is not None:
-            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
-        if self.contact_id is not None:
-            result["contactId"] = from_union([from_str, from_none], self.contact_id)
-        result["createdAt"] = to_float(self.created_at)
-        if self.description is not None:
-            result["description"] = from_union([from_str, from_none], self.description)
-        result["id"] = from_str(self.id)
-        if self.meta is not None:
-            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
-        if self.name is not None:
-            result["name"] = from_union([from_str, from_none], self.name)
-        result["updatedAt"] = to_float(self.updated_at)
-        return result
-
-
-class SpacesExportStreamItemType(Enum):
-    """The type of event"""
-
-    ITEM = "item"
-
-
-class SpacesExportStreamItem:
-    data: SpacesExportStreamItemData
-    """Blueprint properties"""
-
-    type: SpacesExportStreamItemType
-    """The type of event"""
-
-    def __init__(self, data: SpacesExportStreamItemData, type: SpacesExportStreamItemType) -> None:
-        self.data = data
-        self.type = type
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'SpacesExportStreamItem':
-        assert isinstance(obj, dict)
-        data = SpacesExportStreamItemData.from_dict(obj.get("data"))
-        type = SpacesExportStreamItemType(obj.get("type"))
-        return SpacesExportStreamItem(data, type)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        result["data"] = to_class(SpacesExportStreamItemData, self.data)
-        result["type"] = to_enum(SpacesExportStreamItemType, self.type)
-        return result
-
-
-class SpaceListParamsOrder(Enum):
-    """The order of the paginated items"""
-
-    ASC = "asc"
-    DESC = "desc"
-
-
-class SpaceListParams:
-    cursor: Optional[str]
-    """The cursor to use for pagination"""
-
-    meta: Optional[Dict[str, str]]
-    """Key-value pairs to filter the partner users by metadata"""
-
-    order: Optional[SpaceListParamsOrder]
-    """The order of the paginated items"""
-
-    take: Optional[int]
-    """The number of items to retrieve"""
-
-    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[SpaceListParamsOrder], take: Optional[int]) -> None:
-        self.cursor = cursor
-        self.meta = meta
-        self.order = order
-        self.take = take
-
-    @staticmethod
-    def from_dict(obj: Any) -> 'SpaceListParams':
-        assert isinstance(obj, dict)
-        cursor = from_union([from_str, from_none], obj.get("cursor"))
-        meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
-        order = from_union([SpaceListParamsOrder, from_none], obj.get("order"))
-        take = from_union([from_int, from_none], obj.get("take"))
-        return SpaceListParams(cursor, meta, order, take)
-
-    def to_dict(self) -> dict:
-        result: dict = {}
-        if self.cursor is not None:
-            result["cursor"] = from_union([from_str, from_none], self.cursor)
-        if self.meta is not None:
-            result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
-        if self.order is not None:
-            result["order"] = from_union([lambda x: to_enum(SpaceListParamsOrder, x), from_none], self.order)
-        if self.take is not None:
-            result["take"] = from_union([from_int, from_none], self.take)
-        return result
-
-
-class SpaceListResponseItem:
-    """Blueprint properties"""
-
-    blueprint_id: Optional[str]
-    """The ID of the blueprint"""
-
-    contact_id: Optional[str]
-    """The contact associated with the space"""
-
-    created_at: float
-    """The timestamp (ms) when the instance was created"""
-
-    description: Optional[str]
-    """The associated description"""
-
-    id: str
-    """The instance ID"""
-
-    meta: Optional[Dict[str, Any]]
-    """Meta data information"""
-
-    name: Optional[str]
-    """The associated name"""
-
-    updated_at: float
-    """The timestamp (ms) when the instance was updated"""
-
-    def __init__(self, blueprint_id: Optional[str], contact_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float) -> None:
-        self.blueprint_id = blueprint_id
-        self.contact_id = contact_id
-        self.created_at = created_at
-        self.description = description
-        self.id = id
-        self.meta = meta
-        self.name = name
-        self.updated_at = updated_at
-
-    @staticmethod
+    def from_dict(obj: Any) -> 'SpacesExportStreamItemData':
+        assert isinstance(obj, dict)
+        blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
+        contact_id = from_union([from_str, from_none], obj.get("contactId"))
+        created_at = from_float(obj.get("createdAt"))
+        description = from_union([from_str, from_none], obj.get("description"))
+        id = from_str(obj.get("id"))
+        meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
+        name = from_union([from_str, from_none], obj.get("name"))
+        updated_at = from_float(obj.get("updatedAt"))
+        return SpacesExportStreamItemData(blueprint_id, contact_id, created_at, description, id, meta, name, updated_at)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.blueprint_id is not None:
+            result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
+        if self.contact_id is not None:
+            result["contactId"] = from_union([from_str, from_none], self.contact_id)
+        result["createdAt"] = to_float(self.created_at)
+        if self.description is not None:
+            result["description"] = from_union([from_str, from_none], self.description)
+        result["id"] = from_str(self.id)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.meta)
+        if self.name is not None:
+            result["name"] = from_union([from_str, from_none], self.name)
+        result["updatedAt"] = to_float(self.updated_at)
+        return result
+
+
+class SpacesExportStreamItemType(Enum):
+    """The type of event"""
+
+    ITEM = "item"
+
+
+class SpacesExportStreamItem:
+    data: SpacesExportStreamItemData
+    """Blueprint properties"""
+
+    type: SpacesExportStreamItemType
+    """The type of event"""
+
+    def __init__(self, data: SpacesExportStreamItemData, type: SpacesExportStreamItemType) -> None:
+        self.data = data
+        self.type = type
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SpacesExportStreamItem':
+        assert isinstance(obj, dict)
+        data = SpacesExportStreamItemData.from_dict(obj.get("data"))
+        type = SpacesExportStreamItemType(obj.get("type"))
+        return SpacesExportStreamItem(data, type)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        result["data"] = to_class(SpacesExportStreamItemData, self.data)
+        result["type"] = to_enum(SpacesExportStreamItemType, self.type)
+        return result
+
+
+class SpaceListParamsOrder(Enum):
+    """The order of the paginated items"""
+
+    ASC = "asc"
+    DESC = "desc"
+
+
+class SpaceListParams:
+    cursor: Optional[str]
+    """The cursor to use for pagination"""
+
+    meta: Optional[Dict[str, str]]
+    """Key-value pairs to filter the partner users by metadata"""
+
+    order: Optional[SpaceListParamsOrder]
+    """The order of the paginated items"""
+
+    take: Optional[int]
+    """The number of items to retrieve"""
+
+    def __init__(self, cursor: Optional[str], meta: Optional[Dict[str, str]], order: Optional[SpaceListParamsOrder], take: Optional[int]) -> None:
+        self.cursor = cursor
+        self.meta = meta
+        self.order = order
+        self.take = take
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'SpaceListParams':
+        assert isinstance(obj, dict)
+        cursor = from_union([from_str, from_none], obj.get("cursor"))
+        meta = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("meta"))
+        order = from_union([SpaceListParamsOrder, from_none], obj.get("order"))
+        take = from_union([from_int, from_none], obj.get("take"))
+        return SpaceListParams(cursor, meta, order, take)
+
+    def to_dict(self) -> dict:
+        result: dict = {}
+        if self.cursor is not None:
+            result["cursor"] = from_union([from_str, from_none], self.cursor)
+        if self.meta is not None:
+            result["meta"] = from_union([lambda x: from_dict(from_str, x), from_none], self.meta)
+        if self.order is not None:
+            result["order"] = from_union([lambda x: to_enum(SpaceListParamsOrder, x), from_none], self.order)
+        if self.take is not None:
+            result["take"] = from_union([from_int, from_none], self.take)
+        return result
+
+
+class SpaceListResponseItem:
+    """Blueprint properties"""
+
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
+    blueprint_id: Optional[str]
+    """The ID of the blueprint"""
+
+    contact_id: Optional[str]
+    """The contact associated with the space"""
+
+    created_at: float
+    """The timestamp (ms) when the instance was created"""
+
+    description: Optional[str]
+    """The associated description"""
+
+    id: str
+    """The instance ID"""
+
+    meta: Optional[Dict[str, Any]]
+    """Meta data information"""
+
+    name: Optional[str]
+    """The associated name"""
+
+    updated_at: float
+    """The timestamp (ms) when the instance was updated"""
+
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], contact_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float) -> None:
+        self.alias = alias
+        self.blueprint_id = blueprint_id
+        self.contact_id = contact_id
+        self.created_at = created_at
+        self.description = description
+        self.id = id
+        self.meta = meta
+        self.name = name
+        self.updated_at = updated_at
+
+    @staticmethod
     def from_dict(obj: Any) -> 'SpaceListResponseItem':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         contact_id = from_union([from_str, from_none], obj.get("contactId"))
         created_at = from_float(obj.get("createdAt"))
@@ -45598,10 +47820,12 @@ def from_dict(obj: Any) -> 'SpaceListResponseItem':
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
         updated_at = from_float(obj.get("updatedAt"))
-        return SpaceListResponseItem(blueprint_id, contact_id, created_at, description, id, meta, name, updated_at)
+        return SpaceListResponseItem(alias, blueprint_id, contact_id, created_at, description, id, meta, name, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.contact_id is not None:
@@ -45645,6 +47869,9 @@ def to_dict(self) -> dict:
 class SpaceListStreamItemData:
     """Blueprint properties"""
 
+    alias: Optional[str]
+    """The unique alias for the instance"""
+
     blueprint_id: Optional[str]
     """The ID of the blueprint"""
 
@@ -45669,7 +47896,8 @@ class SpaceListStreamItemData:
     updated_at: float
     """The timestamp (ms) when the instance was updated"""
 
-    def __init__(self, blueprint_id: Optional[str], contact_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float) -> None:
+    def __init__(self, alias: Optional[str], blueprint_id: Optional[str], contact_id: Optional[str], created_at: float, description: Optional[str], id: str, meta: Optional[Dict[str, Any]], name: Optional[str], updated_at: float) -> None:
+        self.alias = alias
         self.blueprint_id = blueprint_id
         self.contact_id = contact_id
         self.created_at = created_at
@@ -45682,6 +47910,7 @@ def __init__(self, blueprint_id: Optional[str], contact_id: Optional[str], creat
     @staticmethod
     def from_dict(obj: Any) -> 'SpaceListStreamItemData':
         assert isinstance(obj, dict)
+        alias = from_union([from_str, from_none], obj.get("alias"))
         blueprint_id = from_union([from_str, from_none], obj.get("blueprintId"))
         contact_id = from_union([from_str, from_none], obj.get("contactId"))
         created_at = from_float(obj.get("createdAt"))
@@ -45690,10 +47919,12 @@ def from_dict(obj: Any) -> 'SpaceListStreamItemData':
         meta = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("meta"))
         name = from_union([from_str, from_none], obj.get("name"))
         updated_at = from_float(obj.get("updatedAt"))
-        return SpaceListStreamItemData(blueprint_id, contact_id, created_at, description, id, meta, name, updated_at)
+        return SpaceListStreamItemData(alias, blueprint_id, contact_id, created_at, description, id, meta, name, updated_at)
 
     def to_dict(self) -> dict:
         result: dict = {}
+        if self.alias is not None:
+            result["alias"] = from_union([from_str, from_none], self.alias)
         if self.blueprint_id is not None:
             result["blueprintId"] = from_union([from_str, from_none], self.blueprint_id)
         if self.contact_id is not None:
@@ -48422,6 +50653,7 @@ class PolicyType(Enum):
     """The policy type"""
 
     RETENTION = "retention"
+    USAGE = "usage"
 
 
 class LimitsDatabase:
@@ -53259,6 +55491,142 @@ def integration_sitemap_list_stream_item_to_dict(x: IntegrationSitemapListStream
     return to_class(IntegrationSitemapListStreamItem, x)
 
 
+def skill_server_integration_delete_params_from_dict(s: Any) -> SkillServerIntegrationDeleteParams:
+    return SkillServerIntegrationDeleteParams.from_dict(s)
+
+
+def skill_server_integration_delete_params_to_dict(x: SkillServerIntegrationDeleteParams) -> Any:
+    return to_class(SkillServerIntegrationDeleteParams, x)
+
+
+def skill_server_integration_delete_request_from_dict(s: Any) -> Dict[str, Any]:
+    return from_dict(lambda x: x, s)
+
+
+def skill_server_integration_delete_request_to_dict(x: Dict[str, Any]) -> Any:
+    return from_dict(lambda x: x, x)
+
+
+def skill_server_integration_delete_response_from_dict(s: Any) -> SkillServerIntegrationDeleteResponse:
+    return SkillServerIntegrationDeleteResponse.from_dict(s)
+
+
+def skill_server_integration_delete_response_to_dict(x: SkillServerIntegrationDeleteResponse) -> Any:
+    return to_class(SkillServerIntegrationDeleteResponse, x)
+
+
+def skill_server_integration_fetch_params_from_dict(s: Any) -> SkillServerIntegrationFetchParams:
+    return SkillServerIntegrationFetchParams.from_dict(s)
+
+
+def skill_server_integration_fetch_params_to_dict(x: SkillServerIntegrationFetchParams) -> Any:
+    return to_class(SkillServerIntegrationFetchParams, x)
+
+
+def skill_server_integration_fetch_response_from_dict(s: Any) -> SkillServerIntegrationFetchResponse:
+    return SkillServerIntegrationFetchResponse.from_dict(s)
+
+
+def skill_server_integration_fetch_response_to_dict(x: SkillServerIntegrationFetchResponse) -> Any:
+    return to_class(SkillServerIntegrationFetchResponse, x)
+
+
+def skill_server_manual_fetch_params_from_dict(s: Any) -> SkillServerManualFetchParams:
+    return SkillServerManualFetchParams.from_dict(s)
+
+
+def skill_server_manual_fetch_params_to_dict(x: SkillServerManualFetchParams) -> Any:
+    return to_class(SkillServerManualFetchParams, x)
+
+
+def skill_server_ability_invoke_params_from_dict(s: Any) -> SkillServerAbilityInvokeParams:
+    return SkillServerAbilityInvokeParams.from_dict(s)
+
+
+def skill_server_ability_invoke_params_to_dict(x: SkillServerAbilityInvokeParams) -> Any:
+    return to_class(SkillServerAbilityInvokeParams, x)
+
+
+def skill_server_ability_invoke_request_from_dict(s: Any) -> SkillServerAbilityInvokeRequest:
+    return SkillServerAbilityInvokeRequest.from_dict(s)
+
+
+def skill_server_ability_invoke_request_to_dict(x: SkillServerAbilityInvokeRequest) -> Any:
+    return to_class(SkillServerAbilityInvokeRequest, x)
+
+
+def skill_server_ability_invoke_response_from_dict(s: Any) -> SkillServerAbilityInvokeResponse:
+    return SkillServerAbilityInvokeResponse.from_dict(s)
+
+
+def skill_server_ability_invoke_response_to_dict(x: SkillServerAbilityInvokeResponse) -> Any:
+    return to_class(SkillServerAbilityInvokeResponse, x)
+
+
+def skill_server_integration_update_params_from_dict(s: Any) -> SkillServerIntegrationUpdateParams:
+    return SkillServerIntegrationUpdateParams.from_dict(s)
+
+
+def skill_server_integration_update_params_to_dict(x: SkillServerIntegrationUpdateParams) -> Any:
+    return to_class(SkillServerIntegrationUpdateParams, x)
+
+
+def skill_server_integration_update_request_from_dict(s: Any) -> SkillServerIntegrationUpdateRequest:
+    return SkillServerIntegrationUpdateRequest.from_dict(s)
+
+
+def skill_server_integration_update_request_to_dict(x: SkillServerIntegrationUpdateRequest) -> Any:
+    return to_class(SkillServerIntegrationUpdateRequest, x)
+
+
+def skill_server_integration_update_response_from_dict(s: Any) -> SkillServerIntegrationUpdateResponse:
+    return SkillServerIntegrationUpdateResponse.from_dict(s)
+
+
+def skill_server_integration_update_response_to_dict(x: SkillServerIntegrationUpdateResponse) -> Any:
+    return to_class(SkillServerIntegrationUpdateResponse, x)
+
+
+def skill_server_integration_create_request_from_dict(s: Any) -> SkillServerIntegrationCreateRequest:
+    return SkillServerIntegrationCreateRequest.from_dict(s)
+
+
+def skill_server_integration_create_request_to_dict(x: SkillServerIntegrationCreateRequest) -> Any:
+    return to_class(SkillServerIntegrationCreateRequest, x)
+
+
+def skill_server_integration_create_response_from_dict(s: Any) -> SkillServerIntegrationCreateResponse:
+    return SkillServerIntegrationCreateResponse.from_dict(s)
+
+
+def skill_server_integration_create_response_to_dict(x: SkillServerIntegrationCreateResponse) -> Any:
+    return to_class(SkillServerIntegrationCreateResponse, x)
+
+
+def skill_server_integration_list_params_from_dict(s: Any) -> SkillServerIntegrationListParams:
+    return SkillServerIntegrationListParams.from_dict(s)
+
+
+def skill_server_integration_list_params_to_dict(x: SkillServerIntegrationListParams) -> Any:
+    return to_class(SkillServerIntegrationListParams, x)
+
+
+def skill_server_integration_list_response_from_dict(s: Any) -> SkillServerIntegrationListResponse:
+    return SkillServerIntegrationListResponse.from_dict(s)
+
+
+def skill_server_integration_list_response_to_dict(x: SkillServerIntegrationListResponse) -> Any:
+    return to_class(SkillServerIntegrationListResponse, x)
+
+
+def skill_server_integration_list_stream_item_from_dict(s: Any) -> SkillServerIntegrationListStreamItem:
+    return SkillServerIntegrationListStreamItem.from_dict(s)
+
+
+def skill_server_integration_list_stream_item_to_dict(x: SkillServerIntegrationListStreamItem) -> Any:
+    return to_class(SkillServerIntegrationListStreamItem, x)
+
+
 def integration_slack_delete_params_from_dict(s: Any) -> IntegrationSlackDeleteParams:
     return IntegrationSlackDeleteParams.from_dict(s)
 
@@ -55907,6 +58275,118 @@ def space_fetch_response_to_dict(x: SpaceFetchResponse) -> Any:
     return to_class(SpaceFetchResponse, x)
 
 
+def space_site_delete_params_from_dict(s: Any) -> SpaceSiteDeleteParams:
+    return SpaceSiteDeleteParams.from_dict(s)
+
+
+def space_site_delete_params_to_dict(x: SpaceSiteDeleteParams) -> Any:
+    return to_class(SpaceSiteDeleteParams, x)
+
+
+def space_site_delete_request_from_dict(s: Any) -> Dict[str, Any]:
+    return from_dict(lambda x: x, s)
+
+
+def space_site_delete_request_to_dict(x: Dict[str, Any]) -> Any:
+    return from_dict(lambda x: x, x)
+
+
+def space_site_delete_response_from_dict(s: Any) -> SpaceSiteDeleteResponse:
+    return SpaceSiteDeleteResponse.from_dict(s)
+
+
+def space_site_delete_response_to_dict(x: SpaceSiteDeleteResponse) -> Any:
+    return to_class(SpaceSiteDeleteResponse, x)
+
+
+def space_site_fetch_params_from_dict(s: Any) -> SpaceSiteFetchParams:
+    return SpaceSiteFetchParams.from_dict(s)
+
+
+def space_site_fetch_params_to_dict(x: SpaceSiteFetchParams) -> Any:
+    return to_class(SpaceSiteFetchParams, x)
+
+
+def space_site_fetch_response_from_dict(s: Any) -> SpaceSiteFetchResponse:
+    return SpaceSiteFetchResponse.from_dict(s)
+
+
+def space_site_fetch_response_to_dict(x: SpaceSiteFetchResponse) -> Any:
+    return to_class(SpaceSiteFetchResponse, x)
+
+
+def space_site_update_params_from_dict(s: Any) -> SpaceSiteUpdateParams:
+    return SpaceSiteUpdateParams.from_dict(s)
+
+
+def space_site_update_params_to_dict(x: SpaceSiteUpdateParams) -> Any:
+    return to_class(SpaceSiteUpdateParams, x)
+
+
+def space_site_update_request_from_dict(s: Any) -> SpaceSiteUpdateRequest:
+    return SpaceSiteUpdateRequest.from_dict(s)
+
+
+def space_site_update_request_to_dict(x: SpaceSiteUpdateRequest) -> Any:
+    return to_class(SpaceSiteUpdateRequest, x)
+
+
+def space_site_update_response_from_dict(s: Any) -> SpaceSiteUpdateResponse:
+    return SpaceSiteUpdateResponse.from_dict(s)
+
+
+def space_site_update_response_to_dict(x: SpaceSiteUpdateResponse) -> Any:
+    return to_class(SpaceSiteUpdateResponse, x)
+
+
+def space_site_create_params_from_dict(s: Any) -> SpaceSiteCreateParams:
+    return SpaceSiteCreateParams.from_dict(s)
+
+
+def space_site_create_params_to_dict(x: SpaceSiteCreateParams) -> Any:
+    return to_class(SpaceSiteCreateParams, x)
+
+
+def space_site_create_request_from_dict(s: Any) -> SpaceSiteCreateRequest:
+    return SpaceSiteCreateRequest.from_dict(s)
+
+
+def space_site_create_request_to_dict(x: SpaceSiteCreateRequest) -> Any:
+    return to_class(SpaceSiteCreateRequest, x)
+
+
+def space_site_create_response_from_dict(s: Any) -> SpaceSiteCreateResponse:
+    return SpaceSiteCreateResponse.from_dict(s)
+
+
+def space_site_create_response_to_dict(x: SpaceSiteCreateResponse) -> Any:
+    return to_class(SpaceSiteCreateResponse, x)
+
+
+def space_site_list_params_from_dict(s: Any) -> SpaceSiteListParams:
+    return SpaceSiteListParams.from_dict(s)
+
+
+def space_site_list_params_to_dict(x: SpaceSiteListParams) -> Any:
+    return to_class(SpaceSiteListParams, x)
+
+
+def space_site_list_response_from_dict(s: Any) -> SpaceSiteListResponse:
+    return SpaceSiteListResponse.from_dict(s)
+
+
+def space_site_list_response_to_dict(x: SpaceSiteListResponse) -> Any:
+    return to_class(SpaceSiteListResponse, x)
+
+
+def space_site_list_stream_item_from_dict(s: Any) -> SpaceSiteListStreamItem:
+    return SpaceSiteListStreamItem.from_dict(s)
+
+
+def space_site_list_stream_item_to_dict(x: SpaceSiteListStreamItem) -> Any:
+    return to_class(SpaceSiteListStreamItem, x)
+
+
 def space_storage_path_copy_params_from_dict(s: Any) -> SpaceStoragePathCopyParams:
     return SpaceStoragePathCopyParams.from_dict(s)
 
diff --git a/pyproject.toml b/pyproject.toml
index 476846e..8569b1b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "chatbotkit"
-version = "0.1.0"
+version = "0.2.0"
 description = "Async Python SDK for ChatBotKit"
 readme = "README.md"
 requires-python = ">=3.10"
diff --git a/tests/test_packaging.py b/tests/test_packaging.py
index 98d5ec0..eebd5ae 100644
--- a/tests/test_packaging.py
+++ b/tests/test_packaging.py
@@ -51,6 +51,12 @@ async def test_client_public_surface_imports_and_initializes():
         ]:
             assert hasattr(cbk, name)
 
+        # nested sub-clients
+        assert hasattr(cbk.integration, "skill_server")
+        assert hasattr(cbk.integration, "mcp_server")
+        assert hasattr(cbk.space, "site")
+        assert hasattr(cbk.space, "storage")
+
 
 def test_package_and_examples_compile():
     paths = [
@@ -110,3 +116,16 @@ def test_pyproject_extras_are_publish_ready():
     assert "python-dotenv>=1.0" in extras["examples"]
     assert "build>=1.2" in extras["dev"]
     assert "twine>=5" in extras["dev"]
+
+
+def test_version_is_consistent_across_sources():
+    import chatbotkit
+
+    pyproject = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))
+    pyproject_version = pyproject["project"]["version"]
+
+    assert chatbotkit.__version__ == pyproject_version, (
+        "pyproject.toml version "
+        f"({pyproject_version}) and chatbotkit.__version__ "
+        f"({chatbotkit.__version__}) must match"
+    )