airbyte-agent-zendesk-support 0.18.18__py3-none-any.whl → 0.18.51__py3-none-any.whl

airbyte_agent_zendesk_support/connector.py

@@ -1,17 +1,18 @@
 """
-zendesk-support connector.
+Zendesk-Support connector.
 """
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, AsyncIterator, overload
+import logging
+from typing import TYPE_CHECKING, Any, Callable, TypeVar, AsyncIterator, overload
 try:
     from typing import Literal
 except ImportError:
     from typing_extensions import Literal
 
 from .connector_model import ZendeskSupportConnectorModel
-
+from ._vendored.connector_sdk.introspection import describe_entities, generate_tool_description
 from .types import (
     ArticleAttachmentsDownloadParams,
     ArticleAttachmentsGetParams,
@@ -52,8 +53,32 @@ from .types import (
     UsersListParams,
     ViewsGetParams,
     ViewsListParams,
+    AirbyteSearchParams,
+    BrandsSearchFilter,
+    BrandsSearchQuery,
+    GroupsSearchFilter,
+    GroupsSearchQuery,
+    OrganizationsSearchFilter,
+    OrganizationsSearchQuery,
+    SatisfactionRatingsSearchFilter,
+    SatisfactionRatingsSearchQuery,
+    TagsSearchFilter,
+    TagsSearchQuery,
+    TicketAuditsSearchFilter,
+    TicketAuditsSearchQuery,
+    TicketCommentsSearchFilter,
+    TicketCommentsSearchQuery,
+    TicketFieldsSearchFilter,
+    TicketFieldsSearchQuery,
+    TicketFormsSearchFilter,
+    TicketFormsSearchQuery,
+    TicketMetricsSearchFilter,
+    TicketMetricsSearchQuery,
+    TicketsSearchFilter,
+    TicketsSearchQuery,
+    UsersSearchFilter,
+    UsersSearchQuery,
 )
-
 if TYPE_CHECKING:
     from .models import ZendeskSupportAuthConfig
 # Import specific auth config classes for multi-auth isinstance checks
@@ -63,45 +88,81 @@ from .models import (
     ZendeskSupportExecuteResult,
     ZendeskSupportExecuteResultWithMeta,
     TicketsListResult,
-    TicketsGetResult,
     UsersListResult,
-    UsersGetResult,
     OrganizationsListResult,
-    OrganizationsGetResult,
     GroupsListResult,
-    GroupsGetResult,
     TicketCommentsListResult,
-    AttachmentsGetResult,
     TicketAuditsListResult,
     TicketAuditsListResult,
     TicketMetricsListResult,
     TicketFieldsListResult,
-    TicketFieldsGetResult,
     BrandsListResult,
-    BrandsGetResult,
     ViewsListResult,
-    ViewsGetResult,
     MacrosListResult,
-    MacrosGetResult,
     TriggersListResult,
-    TriggersGetResult,
     AutomationsListResult,
-    AutomationsGetResult,
     TagsListResult,
     SatisfactionRatingsListResult,
-    SatisfactionRatingsGetResult,
     GroupMembershipsListResult,
     OrganizationMembershipsListResult,
     SlaPoliciesListResult,
-    SlaPoliciesGetResult,
     TicketFormsListResult,
-    TicketFormsGetResult,
     ArticlesListResult,
-    ArticlesGetResult,
     ArticleAttachmentsListResult,
-    ArticleAttachmentsGetResult,
+    Article,
+    ArticleAttachment,
+    Attachment,
+    Automation,
+    Brand,
+    Group,
+    GroupMembership,
+    Macro,
+    Organization,
+    OrganizationMembership,
+    SLAPolicy,
+    SatisfactionRating,
+    Tag,
+    Ticket,
+    TicketAudit,
+    TicketComment,
+    TicketField,
+    TicketForm,
+    TicketMetric,
+    Trigger,
+    User,
+    View,
+    AirbyteSearchHit,
+    AirbyteSearchResult,
+    BrandsSearchData,
+    BrandsSearchResult,
+    GroupsSearchData,
+    GroupsSearchResult,
+    OrganizationsSearchData,
+    OrganizationsSearchResult,
+    SatisfactionRatingsSearchData,
+    SatisfactionRatingsSearchResult,
+    TagsSearchData,
+    TagsSearchResult,
+    TicketAuditsSearchData,
+    TicketAuditsSearchResult,
+    TicketCommentsSearchData,
+    TicketCommentsSearchResult,
+    TicketFieldsSearchData,
+    TicketFieldsSearchResult,
+    TicketFormsSearchData,
+    TicketFormsSearchResult,
+    TicketMetricsSearchData,
+    TicketMetricsSearchResult,
+    TicketsSearchData,
+    TicketsSearchResult,
+    UsersSearchData,
+    UsersSearchResult,
 )
 
+# TypeVar for decorator type preservation
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+
 
 class ZendeskSupportConnector:
     """
@@ -111,51 +172,51 @@ class ZendeskSupportConnector:
     """
 
     connector_name = "zendesk-support"
-    connector_version = "0.1.3"
+    connector_version = "0.1.6"
     vendored_sdk_version = "0.1.0"  # Version of vendored connector-sdk
 
-    # Map of (entity, action) -> has_extractors for envelope wrapping decision
-    _EXTRACTOR_MAP = {
+    # Map of (entity, action) -> needs_envelope for envelope wrapping decision
+    _ENVELOPE_MAP = {
         ("tickets", "list"): True,
-        ("tickets", "get"): True,
+        ("tickets", "get"): None,
         ("users", "list"): True,
-        ("users", "get"): True,
+        ("users", "get"): None,
         ("organizations", "list"): True,
-        ("organizations", "get"): True,
+        ("organizations", "get"): None,
         ("groups", "list"): True,
-        ("groups", "get"): True,
+        ("groups", "get"): None,
         ("ticket_comments", "list"): True,
-        ("attachments", "get"): True,
-        ("attachments", "download"): False,
+        ("attachments", "get"): None,
+        ("attachments", "download"): None,
         ("ticket_audits", "list"): True,
         ("ticket_audits", "list"): True,
         ("ticket_metrics", "list"): True,
         ("ticket_fields", "list"): True,
-        ("ticket_fields", "get"): True,
+        ("ticket_fields", "get"): None,
         ("brands", "list"): True,
-        ("brands", "get"): True,
+        ("brands", "get"): None,
         ("views", "list"): True,
-        ("views", "get"): True,
+        ("views", "get"): None,
         ("macros", "list"): True,
-        ("macros", "get"): True,
+        ("macros", "get"): None,
         ("triggers", "list"): True,
-        ("triggers", "get"): True,
+        ("triggers", "get"): None,
         ("automations", "list"): True,
-        ("automations", "get"): True,
+        ("automations", "get"): None,
         ("tags", "list"): True,
         ("satisfaction_ratings", "list"): True,
-        ("satisfaction_ratings", "get"): True,
+        ("satisfaction_ratings", "get"): None,
         ("group_memberships", "list"): True,
         ("organization_memberships", "list"): True,
         ("sla_policies", "list"): True,
-        ("sla_policies", "get"): True,
+        ("sla_policies", "get"): None,
         ("ticket_forms", "list"): True,
-        ("ticket_forms", "get"): True,
+        ("ticket_forms", "get"): None,
         ("articles", "list"): True,
-        ("articles", "get"): True,
+        ("articles", "get"): None,
         ("article_attachments", "list"): True,
-        ("article_attachments", "get"): True,
-        ("article_attachments", "download"): False,
+        ("article_attachments", "get"): None,
+        ("article_attachments", "download"): None,
     }
 
     # Map of (entity, action) -> {python_param_name: api_param_name}
@@ -205,10 +266,9 @@ class ZendeskSupportConnector:
     def __init__(
         self,
         auth_config: ZendeskSupportAuthConfig | None = None,
-        connector_id: str | None = None,
+        external_user_id: str | None = None,
         airbyte_client_id: str | None = None,
         airbyte_client_secret: str | None = None,
-        airbyte_connector_api_url: str | None = None,
         on_token_refresh: Any | None = None,
         subdomain: str | None = None    ):
         """
@@ -216,14 +276,13 @@ class ZendeskSupportConnector:
 
         Supports both local and hosted execution modes:
         - Local mode: Provide `auth_config` for direct API calls
-        - Hosted mode: Provide `connector_id`, `airbyte_client_id`, and `airbyte_client_secret` for hosted execution
+        - Hosted mode: Provide `external_user_id`, `airbyte_client_id`, and `airbyte_client_secret` for hosted execution
 
         Args:
             auth_config: Typed authentication configuration (required for local mode)
-            connector_id: Connector ID (required for hosted mode)
+            external_user_id: External user ID (required for hosted mode)
             airbyte_client_id: Airbyte OAuth client ID (required for hosted mode)
             airbyte_client_secret: Airbyte OAuth client secret (required for hosted mode)
-            airbyte_connector_api_url: Airbyte connector API URL (defaults to Airbyte Cloud API URL)
             on_token_refresh: Optional callback for OAuth2 token refresh persistence.
                 Called with new_tokens dict when tokens are refreshed. Can be sync or async.
                 Example: lambda tokens: save_to_database(tokens)            subdomain: Your Zendesk subdomain
@@ -232,7 +291,7 @@ class ZendeskSupportConnector:
             connector = ZendeskSupportConnector(auth_config=ZendeskSupportAuthConfig(access_token="...", refresh_token="..."))
             # Hosted mode (executed on Airbyte cloud)
             connector = ZendeskSupportConnector(
-                connector_id="connector-456",
+                external_user_id="user-123",
                 airbyte_client_id="client_abc123",
                 airbyte_client_secret="secret_xyz789"
             )
@@ -248,20 +307,20 @@ class ZendeskSupportConnector:
                 on_token_refresh=save_tokens
             )
         """
-        # Hosted mode: connector_id, airbyte_client_id, and airbyte_client_secret provided
-        if connector_id and airbyte_client_id and airbyte_client_secret:
+        # Hosted mode: external_user_id, airbyte_client_id, and airbyte_client_secret provided
+        if external_user_id and airbyte_client_id and airbyte_client_secret:
             from ._vendored.connector_sdk.executor import HostedExecutor
             self._executor = HostedExecutor(
-                connector_id=connector_id,
+                external_user_id=external_user_id,
                 airbyte_client_id=airbyte_client_id,
                 airbyte_client_secret=airbyte_client_secret,
-                api_url=airbyte_connector_api_url,
+                connector_definition_id=str(ZendeskSupportConnectorModel.id),
             )
         else:
             # Local mode: auth_config required
             if not auth_config:
                 raise ValueError(
-                    "Either provide (connector_id, airbyte_client_id, airbyte_client_secret) for hosted mode "
+                    "Either provide (external_user_id, airbyte_client_id, airbyte_client_secret) for hosted mode "
                     "or auth_config for local mode"
                 )
 
@@ -334,7 +393,7 @@ class ZendeskSupportConnector:
         entity: Literal["tickets"],
         action: Literal["get"],
         params: "TicketsGetParams"
-    ) -> "TicketsGetResult": ...
+    ) -> "Ticket": ...
 
     @overload
     async def execute(
@@ -350,7 +409,7 @@ class ZendeskSupportConnector:
         entity: Literal["users"],
         action: Literal["get"],
         params: "UsersGetParams"
-    ) -> "UsersGetResult": ...
+    ) -> "User": ...
 
     @overload
     async def execute(
@@ -366,7 +425,7 @@ class ZendeskSupportConnector:
         entity: Literal["organizations"],
         action: Literal["get"],
         params: "OrganizationsGetParams"
-    ) -> "OrganizationsGetResult": ...
+    ) -> "Organization": ...
 
     @overload
     async def execute(
@@ -382,7 +441,7 @@ class ZendeskSupportConnector:
         entity: Literal["groups"],
         action: Literal["get"],
         params: "GroupsGetParams"
-    ) -> "GroupsGetResult": ...
+    ) -> "Group": ...
 
     @overload
     async def execute(
@@ -398,7 +457,7 @@ class ZendeskSupportConnector:
         entity: Literal["attachments"],
         action: Literal["get"],
         params: "AttachmentsGetParams"
-    ) -> "AttachmentsGetResult": ...
+    ) -> "Attachment": ...
 
     @overload
     async def execute(
@@ -446,7 +505,7 @@ class ZendeskSupportConnector:
         entity: Literal["ticket_fields"],
         action: Literal["get"],
         params: "TicketFieldsGetParams"
-    ) -> "TicketFieldsGetResult": ...
+    ) -> "TicketField": ...
 
     @overload
     async def execute(
@@ -462,7 +521,7 @@ class ZendeskSupportConnector:
         entity: Literal["brands"],
         action: Literal["get"],
         params: "BrandsGetParams"
-    ) -> "BrandsGetResult": ...
+    ) -> "Brand": ...
 
     @overload
     async def execute(
@@ -478,7 +537,7 @@ class ZendeskSupportConnector:
         entity: Literal["views"],
         action: Literal["get"],
         params: "ViewsGetParams"
-    ) -> "ViewsGetResult": ...
+    ) -> "View": ...
 
     @overload
     async def execute(
@@ -494,7 +553,7 @@ class ZendeskSupportConnector:
         entity: Literal["macros"],
         action: Literal["get"],
         params: "MacrosGetParams"
-    ) -> "MacrosGetResult": ...
+    ) -> "Macro": ...
 
     @overload
     async def execute(
@@ -510,7 +569,7 @@ class ZendeskSupportConnector:
         entity: Literal["triggers"],
         action: Literal["get"],
         params: "TriggersGetParams"
-    ) -> "TriggersGetResult": ...
+    ) -> "Trigger": ...
 
     @overload
     async def execute(
@@ -526,7 +585,7 @@ class ZendeskSupportConnector:
         entity: Literal["automations"],
         action: Literal["get"],
         params: "AutomationsGetParams"
-    ) -> "AutomationsGetResult": ...
+    ) -> "Automation": ...
 
     @overload
     async def execute(
@@ -550,7 +609,7 @@ class ZendeskSupportConnector:
         entity: Literal["satisfaction_ratings"],
         action: Literal["get"],
         params: "SatisfactionRatingsGetParams"
-    ) -> "SatisfactionRatingsGetResult": ...
+    ) -> "SatisfactionRating": ...
 
     @overload
     async def execute(
@@ -582,7 +641,7 @@ class ZendeskSupportConnector:
         entity: Literal["sla_policies"],
         action: Literal["get"],
         params: "SlaPoliciesGetParams"
-    ) -> "SlaPoliciesGetResult": ...
+    ) -> "SLAPolicy": ...
 
     @overload
     async def execute(
@@ -598,7 +657,7 @@ class ZendeskSupportConnector:
         entity: Literal["ticket_forms"],
         action: Literal["get"],
         params: "TicketFormsGetParams"
-    ) -> "TicketFormsGetResult": ...
+    ) -> "TicketForm": ...
 
     @overload
     async def execute(
@@ -614,7 +673,7 @@ class ZendeskSupportConnector:
         entity: Literal["articles"],
         action: Literal["get"],
         params: "ArticlesGetParams"
-    ) -> "ArticlesGetResult": ...
+    ) -> "Article": ...
 
     @overload
     async def execute(
@@ -630,7 +689,7 @@ class ZendeskSupportConnector:
         entity: Literal["article_attachments"],
         action: Literal["get"],
         params: "ArticleAttachmentsGetParams"
-    ) -> "ArticleAttachmentsGetResult": ...
+    ) -> "ArticleAttachment": ...
 
     @overload
     async def execute(
@@ -699,7 +758,7 @@ class ZendeskSupportConnector:
             raise RuntimeError(f"Execution failed: {result.error}")
 
         # Check if this operation has extractors configured
-        has_extractors = self._EXTRACTOR_MAP.get((entity, action), False)
+        has_extractors = self._ENVELOPE_MAP.get((entity, action), False)
 
         if has_extractors:
             # With extractors - return Pydantic envelope with data and meta
@@ -714,6 +773,88 @@ class ZendeskSupportConnector:
             # No extractors - return raw response data
             return result.data
 
+    # ===== INTROSPECTION METHODS =====
+
+    @classmethod
+    def describe(cls, func: _F) -> _F:
+        """
+        Decorator that populates a function's docstring with connector capabilities.
+
+        This class method can be used as a decorator to automatically generate
+        comprehensive documentation for AI tool functions.
+
+        Usage:
+            @mcp.tool()
+            @ZendeskSupportConnector.describe
+            async def execute(entity: str, action: str, params: dict):
+                '''Execute operations.'''
+                ...
+
+        The decorated function's __doc__ will be updated with:
+        - Available entities and their actions
+        - Parameter signatures with required (*) and optional (?) markers
+        - Response structure documentation
+        - Example questions (if available in OpenAPI spec)
+
+        Args:
+            func: The function to decorate
+
+        Returns:
+            The same function with updated __doc__
+        """
+        description = generate_tool_description(ZendeskSupportConnectorModel)
+
+        original_doc = func.__doc__ or ""
+        if original_doc.strip():
+            func.__doc__ = f"{original_doc.strip()}\n{description}"
+        else:
+            func.__doc__ = description
+
+        return func
+
+    def list_entities(self) -> list[dict[str, Any]]:
+        """
+        Get structured data about available entities, actions, and parameters.
+
+        Returns a list of entity descriptions with:
+        - entity_name: Name of the entity (e.g., "contacts", "deals")
+        - description: Entity description from the first endpoint
+        - available_actions: List of actions (e.g., ["list", "get", "create"])
+        - parameters: Dict mapping action -> list of parameter dicts
+
+        Example:
+            entities = connector.list_entities()
+            for entity in entities:
+                print(f"{entity['entity_name']}: {entity['available_actions']}")
+        """
+        return describe_entities(ZendeskSupportConnectorModel)
+
+    def entity_schema(self, entity: str) -> dict[str, Any] | None:
+        """
+        Get the JSON schema for an entity.
+
+        Args:
+            entity: Entity name (e.g., "contacts", "companies")
+
+        Returns:
+            JSON schema dict describing the entity structure, or None if not found.
+
+        Example:
+            schema = connector.entity_schema("contacts")
+            if schema:
+                print(f"Contact properties: {list(schema.get('properties', {}).keys())}")
+        """
+        entity_def = next(
+            (e for e in ZendeskSupportConnectorModel.entities if e.name == entity),
+            None
+        )
+        if entity_def is None:
+            logging.getLogger(__name__).warning(
+                f"Entity '{entity}' not found. Available entities: "
+                f"{[e.name for e in ZendeskSupportConnectorModel.entities]}"
+            )
+        return entity_def.entity_schema if entity_def else None
+
 
 
 class TicketsQuery:
@@ -755,7 +896,8 @@ class TicketsQuery:
         # Cast generic envelope to concrete typed result
         return TicketsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -763,7 +905,7 @@ class TicketsQuery:
         self,
         ticket_id: str,
         **kwargs
-    ) -> TicketsGetResult:
+    ) -> Ticket:
         """
         Returns a ticket by its ID
 
@@ -772,7 +914,7 @@ class TicketsQuery:
             **kwargs: Additional parameters
 
         Returns:
-            TicketsGetResult
+            Ticket
         """
         params = {k: v for k, v in {
             "ticket_id": ticket_id,
@@ -780,11 +922,102 @@ class TicketsQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("tickets", "get", params)
-        # Cast generic envelope to concrete typed result
-        return TicketsGetResult(
-            data=result.data        )
+        return result
+
 
 
+    async def search(
+        self,
+        query: TicketsSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> TicketsSearchResult:
+        """
+        Search tickets records from Airbyte cache.
+
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
+
+        Available filter fields (TicketsSearchFilter):
+        - allow_attachments: Boolean indicating whether attachments are allowed on the ticket
+        - allow_channelback: Boolean indicating whether agents can reply to the ticket through the original channel
+        - assignee_id: Unique identifier of the agent currently assigned to the ticket
+        - brand_id: Unique identifier of the brand associated with the ticket in multi-brand accounts
+        - collaborator_ids: Array of user identifiers who are collaborating on the ticket
+        - created_at: Timestamp indicating when the ticket was created
+        - custom_fields: Array of custom field values specific to the account's ticket configuration
+        - custom_status_id: Unique identifier of the custom status applied to the ticket
+        - deleted_ticket_form_id: Unique identifier of the ticket form if it was deleted after the ticket was created
+        - description: Initial description or content of the ticket when it was created
+        - due_at: Timestamp indicating when the ticket is due for completion or resolution
+        - email_cc_ids: Array of user identifiers who are CC'd on ticket email notifications
+        - external_id: External identifier for the ticket, used for integrations with other systems
+        - fields: Array of ticket field values including both system and custom fields
+        - follower_ids: Array of user identifiers who are following the ticket for updates
+        - followup_ids: Array of identifiers for follow-up tickets related to this ticket
+        - forum_topic_id: Unique identifier linking the ticket to a forum topic if applicable
+        - from_messaging_channel: Boolean indicating whether the ticket originated from a messaging channel
+        - generated_timestamp: Timestamp updated for all ticket updates including system changes, used for incremental export co...
+        - group_id: Unique identifier of the agent group assigned to handle the ticket
+        - has_incidents: Boolean indicating whether this problem ticket has related incident tickets
+        - id: Unique identifier for the ticket
+        - is_public: Boolean indicating whether the ticket is publicly visible
+        - organization_id: Unique identifier of the organization associated with the ticket
+        - priority: Priority level assigned to the ticket (e.g., urgent, high, normal, low)
+        - problem_id: Unique identifier of the problem ticket if this is an incident ticket
+        - raw_subject: Original unprocessed subject line before any system modifications
+        - recipient: Email address or identifier of the ticket recipient
+        - requester_id: Unique identifier of the user who requested or created the ticket
+        - satisfaction_rating: Object containing customer satisfaction rating data for the ticket
+        - sharing_agreement_ids: Array of sharing agreement identifiers if the ticket is shared across Zendesk instances
+        - status: Current status of the ticket (e.g., new, open, pending, solved, closed)
+        - subject: Subject line of the ticket describing the issue or request
+        - submitter_id: Unique identifier of the user who submitted the ticket on behalf of the requester
+        - tags: Array of tags applied to the ticket for categorization and filtering
+        - ticket_form_id: Unique identifier of the ticket form used when creating the ticket
+        - type: Type of ticket (e.g., problem, incident, question, task)
+        - updated_at: Timestamp indicating when the ticket was last updated with a ticket event
+        - url: API URL to access the full ticket resource
+        - via: Object describing the channel and method through which the ticket was created
+
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            TicketsSearchResult with hits (list of AirbyteSearchHit[TicketsSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("tickets", "search", params)
+
+        # Parse response into typed result
+        return TicketsSearchResult(
+            hits=[
+                AirbyteSearchHit[TicketsSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=TicketsSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
 
 class UsersQuery:
     """
@@ -825,7 +1058,8 @@ class UsersQuery:
         # Cast generic envelope to concrete typed result
         return UsersListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -833,7 +1067,7 @@ class UsersQuery:
         self,
         user_id: str,
         **kwargs
-    ) -> UsersGetResult:
+    ) -> User:
         """
         Returns a user by their ID
 
@@ -842,7 +1076,7 @@ class UsersQuery:
             **kwargs: Additional parameters
 
         Returns:
-            UsersGetResult
+            User
         """
         params = {k: v for k, v in {
             "user_id": user_id,
@@ -850,11 +1084,101 @@ class UsersQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("users", "get", params)
-        # Cast generic envelope to concrete typed result
-        return UsersGetResult(
-            data=result.data        )
+        return result
+
 
 
+    async def search(
+        self,
+        query: UsersSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> UsersSearchResult:
+        """
+        Search users records from Airbyte cache.
+
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
+
+        Available filter fields (UsersSearchFilter):
+        - active: Indicates if the user account is currently active
+        - alias: Alternative name or nickname for the user
+        - chat_only: Indicates if the user can only interact via chat
+        - created_at: Timestamp indicating when the user was created
+        - custom_role_id: Identifier for a custom role assigned to the user
+        - default_group_id: Identifier of the default group assigned to the user
+        - details: Additional descriptive information about the user
+        - email: Email address of the user
+        - external_id: External system identifier for the user, used for integrations
+        - iana_time_zone: IANA standard time zone identifier for the user
+        - id: Unique identifier for the user
+        - last_login_at: Timestamp of the user's most recent login
+        - locale: Locale setting determining language and regional format preferences
+        - locale_id: Identifier for the user's locale preference
+        - moderator: Indicates if the user has moderator privileges
+        - name: Display name of the user
+        - notes: Internal notes about the user, visible only to agents
+        - only_private_comments: Indicates if the user can only make private comments on tickets
+        - organization_id: Identifier of the organization the user belongs to
+        - permanently_deleted: Indicates if the user has been permanently deleted from the system
+        - phone: Phone number of the user
+        - photo: Profile photo or avatar of the user
+        - report_csv: Indicates if the user receives reports in CSV format
+        - restricted_agent: Indicates if the agent has restricted access permissions
+        - role: Role assigned to the user defining their permissions level
+        - role_type: Type classification of the user's role
+        - shared: Indicates if the user is shared across multiple accounts
+        - shared_agent: Indicates if the user is a shared agent across multiple brands or accounts
+        - shared_phone_number: Indicates if the phone number is shared with other users
+        - signature: Email signature text for the user
+        - suspended: Indicates if the user account is suspended
+        - tags: Labels or tags associated with the user for categorization
+        - ticket_restriction: Defines which tickets the user can access based on restrictions
+        - time_zone: Time zone setting for the user
+        - two_factor_auth_enabled: Indicates if two-factor authentication is enabled for the user
+        - updated_at: Timestamp indicating when the user was last updated
+        - url: API endpoint URL for accessing the user's detailed information
+        - user_fields: Custom field values specific to the user, stored as key-value pairs
+        - verified: Indicates if the user's identity has been verified
+
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            UsersSearchResult with hits (list of AirbyteSearchHit[UsersSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("users", "search", params)
+
+        # Parse response into typed result
+        return UsersSearchResult(
+            hits=[
+                AirbyteSearchHit[UsersSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=UsersSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
 
 class OrganizationsQuery:
     """
@@ -889,7 +1213,8 @@ class OrganizationsQuery:
         # Cast generic envelope to concrete typed result
         return OrganizationsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -897,7 +1222,7 @@ class OrganizationsQuery:
         self,
         organization_id: str,
         **kwargs
-    ) -> OrganizationsGetResult:
+    ) -> Organization:
         """
         Returns an organization by its ID
 
@@ -906,7 +1231,7 @@ class OrganizationsQuery:
             **kwargs: Additional parameters
 
         Returns:
-            OrganizationsGetResult
+            Organization
         """
         params = {k: v for k, v in {
             "organization_id": organization_id,
@@ -914,11 +1239,77 @@ class OrganizationsQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("organizations", "get", params)
-        # Cast generic envelope to concrete typed result
-        return OrganizationsGetResult(
-            data=result.data        )
+        return result
+
+
+
+    async def search(
+        self,
+        query: OrganizationsSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> OrganizationsSearchResult:
+        """
+        Search organizations records from Airbyte cache.
+
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
+
+        Available filter fields (OrganizationsSearchFilter):
+        - created_at: Timestamp when the organization was created
+        - deleted_at: Timestamp when the organization was deleted
+        - details: Details about the organization, such as the address
+        - domain_names: Array of domain names associated with this organization for automatic user assignment
+        - external_id: Unique external identifier to associate the organization to an external record (case-insensitive)
+        - group_id: ID of the group where new tickets from users in this organization are automatically assigned
+        - id: Unique identifier automatically assigned when the organization is created
+        - name: Unique name for the organization (mandatory field)
+        - notes: Notes about the organization
+        - organization_fields: Key-value object for custom organization fields
+        - shared_comments: Boolean indicating whether end users in this organization can comment on each other's tickets
+        - shared_tickets: Boolean indicating whether end users in this organization can see each other's tickets
+        - tags: Array of tags associated with the organization
+        - updated_at: Timestamp of the last update to the organization
+        - url: The API URL of this organization
 
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
 
+        Returns:
+            OrganizationsSearchResult with hits (list of AirbyteSearchHit[OrganizationsSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("organizations", "search", params)
+
+        # Parse response into typed result
+        return OrganizationsSearchResult(
+            hits=[
+                AirbyteSearchHit[OrganizationsSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=OrganizationsSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
 
 class GroupsQuery:
     """
@@ -956,7 +1347,8 @@ class GroupsQuery:
         # Cast generic envelope to concrete typed result
         return GroupsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -964,7 +1356,7 @@ class GroupsQuery:
         self,
         group_id: str,
         **kwargs
-    ) -> GroupsGetResult:
+    ) -> Group:
         """
         Returns a group by its ID
 
@@ -973,7 +1365,7 @@ class GroupsQuery:
             **kwargs: Additional parameters
 
         Returns:
-            GroupsGetResult
+            Group
         """
         params = {k: v for k, v in {
             "group_id": group_id,
@@ -981,12 +1373,72 @@ class GroupsQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("groups", "get", params)
-        # Cast generic envelope to concrete typed result
-        return GroupsGetResult(
-            data=result.data        )
+        return result
 
 
 
+    async def search(
+        self,
+        query: GroupsSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> GroupsSearchResult:
+        """
+        Search groups records from Airbyte cache.
+
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
+
+        Available filter fields (GroupsSearchFilter):
+        - created_at: Timestamp indicating when the group was created
+        - default: Indicates if the group is the default one for the account
+        - deleted: Indicates whether the group has been deleted
+        - description: The description of the group
+        - id: Unique identifier automatically assigned when creating groups
+        - is_public: Indicates if the group is public (true) or private (false)
+        - name: The name of the group
+        - updated_at: Timestamp indicating when the group was last updated
+        - url: The API URL of the group
+
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            GroupsSearchResult with hits (list of AirbyteSearchHit[GroupsSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("groups", "search", params)
+
+        # Parse response into typed result
+        return GroupsSearchResult(
+            hits=[
+                AirbyteSearchHit[GroupsSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=GroupsSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
+
 class TicketCommentsQuery:
     """
     Query class for TicketComments entity operations.
@@ -1029,9 +1481,80 @@ class TicketCommentsQuery:
         # Cast generic envelope to concrete typed result
         return TicketCommentsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
+
 
 
+    async def search(
+        self,
+        query: TicketCommentsSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> TicketCommentsSearchResult:
+        """
+        Search ticket_comments records from Airbyte cache.
+
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
+
+        Available filter fields (TicketCommentsSearchFilter):
+        - attachments: List of files or media attached to the comment
+        - audit_id: Identifier of the audit record associated with this comment event
+        - author_id: Identifier of the user who created the comment
+        - body: Content of the comment in its original format
+        - created_at: Timestamp when the comment was created
+        - event_type: Specific classification of the event within the ticket event stream
+        - html_body: HTML-formatted content of the comment
+        - id: Unique identifier for the comment event
+        - metadata: Additional structured information about the comment not covered by standard fields
+        - plain_body: Plain text content of the comment without formatting
+        - public: Boolean indicating whether the comment is visible to end users or is an internal note
+        - ticket_id: Identifier of the ticket to which this comment belongs
+        - timestamp: Timestamp of when the event occurred in the incremental export stream
+        - type: Type of event, typically indicating this is a comment event
+        - uploads: Array of upload tokens or identifiers for files being attached to the comment
+        - via: Channel or method through which the comment was submitted
+        - via_reference_id: Reference identifier for the channel through which the comment was created
+
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            TicketCommentsSearchResult with hits (list of AirbyteSearchHit[TicketCommentsSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("ticket_comments", "search", params)
+
+        # Parse response into typed result
+        return TicketCommentsSearchResult(
+            hits=[
+                AirbyteSearchHit[TicketCommentsSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=TicketCommentsSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
 
 class AttachmentsQuery:
     """
@@ -1046,7 +1569,7 @@ class AttachmentsQuery:
         self,
         attachment_id: str,
         **kwargs
-    ) -> AttachmentsGetResult:
+    ) -> Attachment:
         """
         Returns an attachment by its ID
 
@@ -1055,7 +1578,7 @@ class AttachmentsQuery:
             **kwargs: Additional parameters
 
         Returns:
-            AttachmentsGetResult
+            Attachment
         """
         params = {k: v for k, v in {
             "attachment_id": attachment_id,
@@ -1063,9 +1586,7 @@ class AttachmentsQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("attachments", "get", params)
-        # Cast generic envelope to concrete typed result
-        return AttachmentsGetResult(
-            data=result.data        )
+        return result
 
 
 
@@ -1160,7 +1681,8 @@ class TicketAuditsQuery:
         # Cast generic envelope to concrete typed result
         return TicketAuditsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -1191,9 +1713,71 @@ class TicketAuditsQuery:
         # Cast generic envelope to concrete typed result
         return TicketAuditsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
+
 
 
+    async def search(
+        self,
+        query: TicketAuditsSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> TicketAuditsSearchResult:
+        """
+        Search ticket_audits records from Airbyte cache.
+
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
+
+        Available filter fields (TicketAuditsSearchFilter):
+        - attachments: Files or documents attached to the audit
+        - author_id: The unique identifier of the user who created the audit
+        - created_at: Timestamp indicating when the audit was created
+        - events: Array of events that occurred in this audit, such as field changes, comments, or tag updates
+        - id: Unique identifier for the audit record, automatically assigned when the audit is created
+        - metadata: Custom and system data associated with the audit
+        - ticket_id: The unique identifier of the ticket associated with this audit
+        - via: Describes how the audit was created, providing context about the creation source
+
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            TicketAuditsSearchResult with hits (list of AirbyteSearchHit[TicketAuditsSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("ticket_audits", "search", params)
+
+        # Parse response into typed result
+        return TicketAuditsSearchResult(
+            hits=[
+                AirbyteSearchHit[TicketAuditsSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=TicketAuditsSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
 
 class TicketMetricsQuery:
     """
@@ -1228,9 +1812,93 @@ class TicketMetricsQuery:
         # Cast generic envelope to concrete typed result
         return TicketMetricsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
+
+
 
+    async def search(
+        self,
+        query: TicketMetricsSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> TicketMetricsSearchResult:
+        """
+        Search ticket_metrics records from Airbyte cache.
+
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
+
+        Available filter fields (TicketMetricsSearchFilter):
+        - agent_wait_time_in_minutes: Number of minutes the agent spent waiting during calendar and business hours
+        - assigned_at: Timestamp when the ticket was assigned
+        - assignee_stations: Number of assignees the ticket had
+        - assignee_updated_at: Timestamp when the assignee last updated the ticket
+        - created_at: Timestamp when the metric record was created
+        - custom_status_updated_at: Timestamp when the ticket's custom status was last updated
+        - first_resolution_time_in_minutes: Number of minutes to the first resolution time during calendar and business hours
+        - full_resolution_time_in_minutes: Number of minutes to the full resolution during calendar and business hours
+        - generated_timestamp: Timestamp of when record was last updated
+        - group_stations: Number of groups the ticket passed through
+        - id: Unique identifier for the ticket metric record
+        - initially_assigned_at: Timestamp when the ticket was initially assigned
+        - instance_id: ID of the Zendesk instance associated with the ticket
+        - latest_comment_added_at: Timestamp when the latest comment was added
+        - metric: Ticket metrics data
+        - on_hold_time_in_minutes: Number of minutes on hold
+        - reopens: Total number of times the ticket was reopened
+        - replies: The number of public replies added to a ticket by an agent
+        - reply_time_in_minutes: Number of minutes to the first reply during calendar and business hours
+        - reply_time_in_seconds: Number of seconds to the first reply during calendar hours, only available for Messaging tickets
+        - requester_updated_at: Timestamp when the requester last updated the ticket
+        - requester_wait_time_in_minutes: Number of minutes the requester spent waiting during calendar and business hours
+        - solved_at: Timestamp when the ticket was solved
+        - status: The current status of the ticket (open, pending, solved, etc.).
+        - status_updated_at: Timestamp when the status of the ticket was last updated
+        - ticket_id: Identifier of the associated ticket
+        - time: Time related to the ticket
+        - type: Type of ticket
+        - updated_at: Timestamp when the metric record was last updated
+        - url: The API url of the ticket metric
 
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            TicketMetricsSearchResult with hits (list of AirbyteSearchHit[TicketMetricsSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("ticket_metrics", "search", params)
+
+        # Parse response into typed result
+        return TicketMetricsSearchResult(
+            hits=[
+                AirbyteSearchHit[TicketMetricsSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=TicketMetricsSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
 
 class TicketFieldsQuery:
     """
@@ -1268,7 +1936,8 @@ class TicketFieldsQuery:
         # Cast generic envelope to concrete typed result
         return TicketFieldsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -1276,7 +1945,7 @@ class TicketFieldsQuery:
         self,
         ticket_field_id: str,
         **kwargs
-    ) -> TicketFieldsGetResult:
+    ) -> TicketField:
         """
         Returns a ticket field by its ID
 
@@ -1285,7 +1954,7 @@ class TicketFieldsQuery:
             **kwargs: Additional parameters
 
         Returns:
-            TicketFieldsGetResult
+            TicketField
         """
         params = {k: v for k, v in {
             "ticket_field_id": ticket_field_id,
@@ -1293,11 +1962,89 @@ class TicketFieldsQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("ticket_fields", "get", params)
-        # Cast generic envelope to concrete typed result
-        return TicketFieldsGetResult(
-            data=result.data        )
+        return result
+
 
 
+    async def search(
+        self,
+        query: TicketFieldsSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> TicketFieldsSearchResult:
+        """
+        Search ticket_fields records from Airbyte cache.
+
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
+
+        Available filter fields (TicketFieldsSearchFilter):
+        - active: Whether this field is currently available for use
+        - agent_description: A description of the ticket field that only agents can see
+        - collapsed_for_agents: If true, the field is shown to agents by default; if false, it is hidden alongside infrequently u...
+        - created_at: Timestamp when the custom ticket field was created
+        - custom_field_options: Array of option objects for custom ticket fields of type multiselect or tagger, containing name a...
+        - custom_statuses: List of customized ticket statuses, only present for system ticket fields of type custom_status
+        - description: Text describing the purpose of the ticket field to users
+        - editable_in_portal: Whether this field is editable by end users in Help Center
+        - id: Unique identifier for the ticket field, automatically assigned when created
+        - key: Internal identifier or reference key for the field
+        - position: The relative position of the ticket field on a ticket, controlling display order
+        - raw_description: The dynamic content placeholder if present, or the description value if not
+        - raw_title: The dynamic content placeholder if present, or the title value if not
+        - raw_title_in_portal: The dynamic content placeholder if present, or the title_in_portal value if not
+        - regexp_for_validation: For regexp fields only, the validation pattern for a field value to be deemed valid
+        - removable: If false, this field is a system field that must be present on all tickets
+        - required: If true, agents must enter a value in the field to change the ticket status to solved
+        - required_in_portal: If true, end users must enter a value in the field to create a request
+        - sub_type_id: For system ticket fields of type priority and status, controlling available options
+        - system_field_options: Array of options for system ticket fields of type tickettype, priority, or status
+        - tag: For checkbox fields only, a tag added to tickets when the checkbox field is selected
+        - title: The title of the ticket field displayed to agents
+        - title_in_portal: The title of the ticket field displayed to end users in Help Center
+        - type: Field type such as text, textarea, checkbox, date, integer, decimal, regexp, multiselect, tagger,...
+        - updated_at: Timestamp when the custom ticket field was last updated
+        - url: The API URL for this ticket field resource
+        - visible_in_portal: Whether this field is visible to end users in Help Center
+
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            TicketFieldsSearchResult with hits (list of AirbyteSearchHit[TicketFieldsSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("ticket_fields", "search", params)
+
+        # Parse response into typed result
+        return TicketFieldsSearchResult(
+            hits=[
+                AirbyteSearchHit[TicketFieldsSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=TicketFieldsSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
 
 class BrandsQuery:
     """
@@ -1332,7 +2079,8 @@ class BrandsQuery:
         # Cast generic envelope to concrete typed result
         return BrandsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -1340,7 +2088,7 @@ class BrandsQuery:
         self,
         brand_id: str,
         **kwargs
-    ) -> BrandsGetResult:
+    ) -> Brand:
         """
         Returns a brand by its ID
 
@@ -1349,7 +2097,7 @@ class BrandsQuery:
             **kwargs: Additional parameters
 
         Returns:
-            BrandsGetResult
+            Brand
         """
         params = {k: v for k, v in {
             "brand_id": brand_id,
@@ -1357,11 +2105,78 @@ class BrandsQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("brands", "get", params)
-        # Cast generic envelope to concrete typed result
-        return BrandsGetResult(
-            data=result.data        )
+        return result
+
+
+
+    async def search(
+        self,
+        query: BrandsSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> BrandsSearchResult:
+        """
+        Search brands records from Airbyte cache.
 
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
 
+        Available filter fields (BrandsSearchFilter):
+        - active: Indicates whether the brand is set as active
+        - brand_url: The public URL of the brand
+        - created_at: Timestamp when the brand was created
+        - default: Indicates whether the brand is the default brand for tickets generated from non-branded channels
+        - has_help_center: Indicates whether the brand has a Help Center enabled
+        - help_center_state: The state of the Help Center, with allowed values of enabled, disabled, or restricted
+        - host_mapping: The host mapping configuration for the brand, visible only to administrators
+        - id: Unique identifier automatically assigned when the brand is created
+        - is_deleted: Indicates whether the brand has been deleted
+        - logo: Brand logo image file represented as an Attachment object
+        - name: The name of the brand
+        - signature_template: The signature template used for the brand
+        - subdomain: The subdomain associated with the brand
+        - ticket_form_ids: Array of ticket form IDs that are available for use by this brand
+        - updated_at: Timestamp when the brand was last updated
+        - url: The API URL for accessing this brand resource
+
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            BrandsSearchResult with hits (list of AirbyteSearchHit[BrandsSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("brands", "search", params)
+
+        # Parse response into typed result
+        return BrandsSearchResult(
+            hits=[
+                AirbyteSearchHit[BrandsSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=BrandsSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
 
 class ViewsQuery:
     """
@@ -1411,7 +2226,8 @@ class ViewsQuery:
         # Cast generic envelope to concrete typed result
         return ViewsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -1419,7 +2235,7 @@ class ViewsQuery:
         self,
         view_id: str,
         **kwargs
-    ) -> ViewsGetResult:
+    ) -> View:
         """
         Returns a view by its ID
 
@@ -1428,7 +2244,7 @@ class ViewsQuery:
             **kwargs: Additional parameters
 
         Returns:
-            ViewsGetResult
+            View
         """
         params = {k: v for k, v in {
             "view_id": view_id,
@@ -1436,9 +2252,7 @@ class ViewsQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("views", "get", params)
-        # Cast generic envelope to concrete typed result
-        return ViewsGetResult(
-            data=result.data        )
+        return result
 
 
 
@@ -1496,7 +2310,8 @@ class MacrosQuery:
         # Cast generic envelope to concrete typed result
         return MacrosListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -1504,7 +2319,7 @@ class MacrosQuery:
         self,
         macro_id: str,
         **kwargs
-    ) -> MacrosGetResult:
+    ) -> Macro:
         """
         Returns a macro by its ID
 
@@ -1513,7 +2328,7 @@ class MacrosQuery:
             **kwargs: Additional parameters
 
         Returns:
-            MacrosGetResult
+            Macro
         """
         params = {k: v for k, v in {
             "macro_id": macro_id,
@@ -1521,9 +2336,7 @@ class MacrosQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("macros", "get", params)
-        # Cast generic envelope to concrete typed result
-        return MacrosGetResult(
-            data=result.data        )
+        return result
 
 
 
@@ -1569,7 +2382,8 @@ class TriggersQuery:
         # Cast generic envelope to concrete typed result
         return TriggersListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -1577,7 +2391,7 @@ class TriggersQuery:
         self,
         trigger_id: str,
         **kwargs
-    ) -> TriggersGetResult:
+    ) -> Trigger:
         """
         Returns a trigger by its ID
 
@@ -1586,7 +2400,7 @@ class TriggersQuery:
             **kwargs: Additional parameters
 
         Returns:
-            TriggersGetResult
+            Trigger
         """
         params = {k: v for k, v in {
             "trigger_id": trigger_id,
@@ -1594,9 +2408,7 @@ class TriggersQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("triggers", "get", params)
-        # Cast generic envelope to concrete typed result
-        return TriggersGetResult(
-            data=result.data        )
+        return result
 
 
 
@@ -1639,7 +2451,8 @@ class AutomationsQuery:
         # Cast generic envelope to concrete typed result
         return AutomationsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -1647,7 +2460,7 @@ class AutomationsQuery:
         self,
         automation_id: str,
         **kwargs
-    ) -> AutomationsGetResult:
+    ) -> Automation:
         """
         Returns an automation by its ID
 
@@ -1656,7 +2469,7 @@ class AutomationsQuery:
             **kwargs: Additional parameters
 
         Returns:
-            AutomationsGetResult
+            Automation
         """
         params = {k: v for k, v in {
             "automation_id": automation_id,
@@ -1664,9 +2477,7 @@ class AutomationsQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("automations", "get", params)
-        # Cast generic envelope to concrete typed result
-        return AutomationsGetResult(
-            data=result.data        )
+        return result
 
 
 
@@ -1703,9 +2514,65 @@ class TagsQuery:
         # Cast generic envelope to concrete typed result
         return TagsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
+
 
 
+    async def search(
+        self,
+        query: TagsSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> TagsSearchResult:
+        """
+        Search tags records from Airbyte cache.
+
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
+
+        Available filter fields (TagsSearchFilter):
+        - count: The number of times this tag has been used across resources
+        - name: The tag name string used to label and categorize resources
+
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            TagsSearchResult with hits (list of AirbyteSearchHit[TagsSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("tags", "search", params)
+
+        # Parse response into typed result
+        return TagsSearchResult(
+            hits=[
+                AirbyteSearchHit[TagsSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=TagsSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
 
 class SatisfactionRatingsQuery:
     """
@@ -1749,7 +2616,8 @@ class SatisfactionRatingsQuery:
         # Cast generic envelope to concrete typed result
         return SatisfactionRatingsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -1757,7 +2625,7 @@ class SatisfactionRatingsQuery:
         self,
         satisfaction_rating_id: str,
         **kwargs
-    ) -> SatisfactionRatingsGetResult:
+    ) -> SatisfactionRating:
         """
         Returns a satisfaction rating by its ID
 
@@ -1766,7 +2634,7 @@ class SatisfactionRatingsQuery:
             **kwargs: Additional parameters
 
         Returns:
-            SatisfactionRatingsGetResult
+            SatisfactionRating
         """
         params = {k: v for k, v in {
             "satisfaction_rating_id": satisfaction_rating_id,
@@ -1774,11 +2642,74 @@ class SatisfactionRatingsQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("satisfaction_ratings", "get", params)
-        # Cast generic envelope to concrete typed result
-        return SatisfactionRatingsGetResult(
-            data=result.data        )
+        return result
+
+
+
+    async def search(
+        self,
+        query: SatisfactionRatingsSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> SatisfactionRatingsSearchResult:
+        """
+        Search satisfaction_ratings records from Airbyte cache.
 
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
 
+        Available filter fields (SatisfactionRatingsSearchFilter):
+        - assignee_id: The identifier of the agent assigned to the ticket at the time the rating was submitted
+        - comment: Optional comment provided by the requester with the rating
+        - created_at: Timestamp indicating when the satisfaction rating was created
+        - group_id: The identifier of the group assigned to the ticket at the time the rating was submitted
+        - id: Unique identifier for the satisfaction rating, automatically assigned upon creation
+        - reason: Free-text reason for a bad rating provided by the requester in a follow-up question
+        - reason_id: Identifier for the predefined reason given for a negative rating, only applicable when score is '...
+        - requester_id: The identifier of the ticket requester who submitted the satisfaction rating
+        - score: The satisfaction rating value: 'offered', 'unoffered', 'good', or 'bad'
+        - ticket_id: The identifier of the ticket being rated
+        - updated_at: Timestamp indicating when the satisfaction rating was last updated
+        - url: The API URL of this satisfaction rating resource
+
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            SatisfactionRatingsSearchResult with hits (list of AirbyteSearchHit[SatisfactionRatingsSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("satisfaction_ratings", "search", params)
+
+        # Parse response into typed result
+        return SatisfactionRatingsSearchResult(
+            hits=[
+                AirbyteSearchHit[SatisfactionRatingsSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=SatisfactionRatingsSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
 
 class GroupMembershipsQuery:
     """
@@ -1813,7 +2744,8 @@ class GroupMembershipsQuery:
         # Cast generic envelope to concrete typed result
         return GroupMembershipsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -1850,7 +2782,8 @@ class OrganizationMembershipsQuery:
         # Cast generic envelope to concrete typed result
         return OrganizationMembershipsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -1887,7 +2820,8 @@ class SlaPoliciesQuery:
         # Cast generic envelope to concrete typed result
         return SlaPoliciesListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -1895,7 +2829,7 @@ class SlaPoliciesQuery:
         self,
         sla_policy_id: str,
         **kwargs
-    ) -> SlaPoliciesGetResult:
+    ) -> SLAPolicy:
         """
         Returns an SLA policy by its ID
 
@@ -1904,7 +2838,7 @@ class SlaPoliciesQuery:
             **kwargs: Additional parameters
 
         Returns:
-            SlaPoliciesGetResult
+            SLAPolicy
         """
         params = {k: v for k, v in {
             "sla_policy_id": sla_policy_id,
@@ -1912,9 +2846,7 @@ class SlaPoliciesQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("sla_policies", "get", params)
-        # Cast generic envelope to concrete typed result
-        return SlaPoliciesGetResult(
-            data=result.data        )
+        return result
 
 
 
@@ -1957,7 +2889,8 @@ class TicketFormsQuery:
         # Cast generic envelope to concrete typed result
         return TicketFormsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -1965,7 +2898,7 @@ class TicketFormsQuery:
         self,
         ticket_form_id: str,
         **kwargs
-    ) -> TicketFormsGetResult:
+    ) -> TicketForm:
         """
         Returns a ticket form by its ID
 
@@ -1974,7 +2907,7 @@ class TicketFormsQuery:
             **kwargs: Additional parameters
 
         Returns:
-            TicketFormsGetResult
+            TicketForm
         """
         params = {k: v for k, v in {
             "ticket_form_id": ticket_form_id,
@@ -1982,11 +2915,79 @@ class TicketFormsQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("ticket_forms", "get", params)
-        # Cast generic envelope to concrete typed result
-        return TicketFormsGetResult(
-            data=result.data        )
+        return result
+
+
+
+    async def search(
+        self,
+        query: TicketFormsSearchQuery,
+        limit: int | None = None,
+        cursor: str | None = None,
+        fields: list[list[str]] | None = None,
+    ) -> TicketFormsSearchResult:
+        """
+        Search ticket_forms records from Airbyte cache.
 
+        This operation searches cached data from Airbyte syncs.
+        Only available in hosted execution mode.
 
+        Available filter fields (TicketFormsSearchFilter):
+        - active: Indicates if the form is set as active
+        - agent_conditions: Array of condition sets for agent workspaces
+        - created_at: Timestamp when the ticket form was created
+        - default: Indicates if the form is the default form for this account
+        - display_name: The name of the form that is displayed to an end user
+        - end_user_conditions: Array of condition sets for end user products
+        - end_user_visible: Indicates if the form is visible to the end user
+        - id: Unique identifier for the ticket form, automatically assigned when creating the form
+        - in_all_brands: Indicates if the form is available for use in all brands on this account
+        - name: The name of the ticket form
+        - position: The position of this form among other forms in the account, such as in a dropdown
+        - raw_display_name: The dynamic content placeholder if present, or the display_name value if not
+        - raw_name: The dynamic content placeholder if present, or the name value if not
+        - restricted_brand_ids: IDs of all brands that this ticket form is restricted to
+        - ticket_field_ids: IDs of all ticket fields included in this ticket form, ordered to determine field display sequenc...
+        - updated_at: Timestamp of the last update to the ticket form
+        - url: URL of the ticket form
+
+        Args:
+            query: Filter and sort conditions. Supports operators like eq, neq, gt, gte, lt, lte,
+                   in, like, fuzzy, keyword, not, and, or. Example: {"filter": {"eq": {"status": "active"}}}
+            limit: Maximum results to return (default 1000)
+            cursor: Pagination cursor from previous response's next_cursor
+            fields: Field paths to include in results. Each path is a list of keys for nested access.
+                    Example: [["id"], ["user", "name"]] returns id and user.name fields.
+
+        Returns:
+            TicketFormsSearchResult with hits (list of AirbyteSearchHit[TicketFormsSearchData]) and pagination info
+
+        Raises:
+            NotImplementedError: If called in local execution mode
+        """
+        params: dict[str, Any] = {"query": query}
+        if limit is not None:
+            params["limit"] = limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if fields is not None:
+            params["fields"] = fields
+
+        result = await self._connector.execute("ticket_forms", "search", params)
+
+        # Parse response into typed result
+        return TicketFormsSearchResult(
+            hits=[
+                AirbyteSearchHit[TicketFormsSearchData](
+                    id=hit.get("id"),
+                    score=hit.get("score"),
+                    data=TicketFormsSearchData(**hit.get("data", {}))
+                )
+                for hit in result.get("hits", [])
+            ],
+            next_cursor=result.get("next_cursor"),
+            took_ms=result.get("took_ms")
+        )
 
 class ArticlesQuery:
     """
@@ -2027,7 +3028,8 @@ class ArticlesQuery:
         # Cast generic envelope to concrete typed result
         return ArticlesListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -2035,7 +3037,7 @@ class ArticlesQuery:
         self,
         id: str | None = None,
         **kwargs
-    ) -> ArticlesGetResult:
+    ) -> Article:
         """
         Retrieves the details of a specific article
 
@@ -2044,7 +3046,7 @@ class ArticlesQuery:
             **kwargs: Additional parameters
 
         Returns:
-            ArticlesGetResult
+            Article
         """
         params = {k: v for k, v in {
             "id": id,
@@ -2052,9 +3054,7 @@ class ArticlesQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("articles", "get", params)
-        # Cast generic envelope to concrete typed result
-        return ArticlesGetResult(
-            data=result.data        )
+        return result
 
 
 
@@ -2094,7 +3094,8 @@ class ArticleAttachmentsQuery:
         # Cast generic envelope to concrete typed result
         return ArticleAttachmentsListResult(
             data=result.data,
-            meta=result.meta        )
+            meta=result.meta
+        )
 
 
 
@@ -2103,7 +3104,7 @@ class ArticleAttachmentsQuery:
         article_id: str,
         attachment_id: str,
         **kwargs
-    ) -> ArticleAttachmentsGetResult:
+    ) -> ArticleAttachment:
         """
         Retrieves the metadata of a specific attachment for a specific article
 
@@ -2113,7 +3114,7 @@ class ArticleAttachmentsQuery:
             **kwargs: Additional parameters
 
         Returns:
-            ArticleAttachmentsGetResult
+            ArticleAttachment
         """
         params = {k: v for k, v in {
             "article_id": article_id,
@@ -2122,9 +3123,7 @@ class ArticleAttachmentsQuery:
         }.items() if v is not None}
 
         result = await self._connector.execute("article_attachments", "get", params)
-        # Cast generic envelope to concrete typed result
-        return ArticleAttachmentsGetResult(
-            data=result.data        )
+        return result