# Generated by ariadne-codegen
# Source: ./documents

from typing import Any, Dict, List, Optional, Union

from .add_contents_to_collections import AddContentsToCollections
from .async_base_client import AsyncBaseClient
from .base_model import UNSET, UnsetType
from .clear_conversation import ClearConversation
from .close_conversation import CloseConversation
from .count_alerts import CountAlerts
from .count_categories import CountCategories
from .count_collections import CountCollections
from .count_contents import CountContents
from .count_conversations import CountConversations
from .count_events import CountEvents
from .count_feeds import CountFeeds
from .count_labels import CountLabels
from .count_organizations import CountOrganizations
from .count_persons import CountPersons
from .count_places import CountPlaces
from .count_products import CountProducts
from .count_repos import CountRepos
from .count_softwares import CountSoftwares
from .count_specifications import CountSpecifications
from .count_workflows import CountWorkflows
from .create_alert import CreateAlert
from .create_category import CreateCategory
from .create_collection import CreateCollection
from .create_conversation import CreateConversation
from .create_event import CreateEvent
from .create_feed import CreateFeed
from .create_label import CreateLabel
from .create_observation import CreateObservation
from .create_organization import CreateOrganization
from .create_person import CreatePerson
from .create_place import CreatePlace
from .create_product import CreateProduct
from .create_repo import CreateRepo
from .create_software import CreateSoftware
from .create_specification import CreateSpecification
from .create_workflow import CreateWorkflow
from .delete_alert import DeleteAlert
from .delete_alerts import DeleteAlerts
from .delete_all_alerts import DeleteAllAlerts
from .delete_all_categories import DeleteAllCategories
from .delete_all_collections import DeleteAllCollections
from .delete_all_contents import DeleteAllContents
from .delete_all_conversations import DeleteAllConversations
from .delete_all_events import DeleteAllEvents
from .delete_all_feeds import DeleteAllFeeds
from .delete_all_labels import DeleteAllLabels
from .delete_all_organizations import DeleteAllOrganizations
from .delete_all_persons import DeleteAllPersons
from .delete_all_places import DeleteAllPlaces
from .delete_all_products import DeleteAllProducts
from .delete_all_repos import DeleteAllRepos
from .delete_all_softwares import DeleteAllSoftwares
from .delete_all_specifications import DeleteAllSpecifications
from .delete_all_workflows import DeleteAllWorkflows
from .delete_categories import DeleteCategories
from .delete_category import DeleteCategory
from .delete_collection import DeleteCollection
from .delete_collections import DeleteCollections
from .delete_content import DeleteContent
from .delete_contents import DeleteContents
from .delete_conversation import DeleteConversation
from .delete_conversations import DeleteConversations
from .delete_event import DeleteEvent
from .delete_events import DeleteEvents
from .delete_feed import DeleteFeed
from .delete_feeds import DeleteFeeds
from .delete_label import DeleteLabel
from .delete_labels import DeleteLabels
from .delete_observation import DeleteObservation
from .delete_organization import DeleteOrganization
from .delete_organizations import DeleteOrganizations
from .delete_person import DeletePerson
from .delete_persons import DeletePersons
from .delete_place import DeletePlace
from .delete_places import DeletePlaces
from .delete_product import DeleteProduct
from .delete_products import DeleteProducts
from .delete_repo import DeleteRepo
from .delete_repos import DeleteRepos
from .delete_software import DeleteSoftware
from .delete_softwares import DeleteSoftwares
from .delete_specification import DeleteSpecification
from .delete_specifications import DeleteSpecifications
from .delete_workflow import DeleteWorkflow
from .delete_workflows import DeleteWorkflows
from .disable_alert import DisableAlert
from .disable_feed import DisableFeed
from .enable_alert import EnableAlert
from .enable_feed import EnableFeed
from .enums import TextTypes
from .extract_contents import ExtractContents
from .get_alert import GetAlert
from .get_category import GetCategory
from .get_collection import GetCollection
from .get_content import GetContent
from .get_conversation import GetConversation
from .get_event import GetEvent
from .get_feed import GetFeed
from .get_label import GetLabel
from .get_organization import GetOrganization
from .get_person import GetPerson
from .get_place import GetPlace
from .get_product import GetProduct
from .get_project import GetProject
from .get_repo import GetRepo
from .get_share_point_consent_uri import GetSharePointConsentUri
from .get_software import GetSoftware
from .get_specification import GetSpecification
from .get_workflow import GetWorkflow
from .ingest_encoded_file import IngestEncodedFile
from .ingest_text import IngestText
from .ingest_uri import IngestUri
from .input_types import (
    AlertFilter,
    AlertInput,
    AlertUpdateInput,
    CategoryFilter,
    CategoryInput,
    CategoryUpdateInput,
    CollectionFilter,
    CollectionInput,
    CollectionUpdateInput,
    ContentFacetInput,
    ContentFilter,
    ContentGraphInput,
    ContentPublishingConnectorInput,
    ContentUpdateInput,
    ConversationFilter,
    ConversationInput,
    ConversationUpdateInput,
    EntityReferenceInput,
    EventFilter,
    EventInput,
    EventUpdateInput,
    FeedFilter,
    FeedInput,
    FeedUpdateInput,
    LabelFilter,
    LabelInput,
    LabelUpdateInput,
    MicrosoftTeamsChannelsInput,
    MicrosoftTeamsTeamsInput,
    ObservationInput,
    ObservationUpdateInput,
    OneDriveFoldersInput,
    OrganizationFilter,
    OrganizationInput,
    OrganizationUpdateInput,
    PersonFilter,
    PersonInput,
    PersonUpdateInput,
    PlaceFilter,
    PlaceInput,
    PlaceUpdateInput,
    ProductFilter,
    ProductInput,
    ProductUpdateInput,
    ProjectUpdateInput,
    RepoFilter,
    RepoInput,
    RepoUpdateInput,
    SharePointFoldersInput,
    SharePointLibrariesInput,
    SoftwareFilter,
    SoftwareInput,
    SoftwareUpdateInput,
    SpecificationFilter,
    SpecificationInput,
    SpecificationUpdateInput,
    SummarizationStrategyInput,
    WorkflowFilter,
    WorkflowInput,
    WorkflowUpdateInput,
)
from .is_content_done import IsContentDone
from .is_feed_done import IsFeedDone
from .lookup_credits import LookupCredits
from .lookup_usage import LookupUsage
from .operations import (
    ADD_CONTENTS_TO_COLLECTIONS_GQL,
    CLEAR_CONVERSATION_GQL,
    CLOSE_CONVERSATION_GQL,
    COUNT_ALERTS_GQL,
    COUNT_CATEGORIES_GQL,
    COUNT_COLLECTIONS_GQL,
    COUNT_CONTENTS_GQL,
    COUNT_CONVERSATIONS_GQL,
    COUNT_EVENTS_GQL,
    COUNT_FEEDS_GQL,
    COUNT_LABELS_GQL,
    COUNT_ORGANIZATIONS_GQL,
    COUNT_PERSONS_GQL,
    COUNT_PLACES_GQL,
    COUNT_PRODUCTS_GQL,
    COUNT_REPOS_GQL,
    COUNT_SOFTWARES_GQL,
    COUNT_SPECIFICATIONS_GQL,
    COUNT_WORKFLOWS_GQL,
    CREATE_ALERT_GQL,
    CREATE_CATEGORY_GQL,
    CREATE_COLLECTION_GQL,
    CREATE_CONVERSATION_GQL,
    CREATE_EVENT_GQL,
    CREATE_FEED_GQL,
    CREATE_LABEL_GQL,
    CREATE_OBSERVATION_GQL,
    CREATE_ORGANIZATION_GQL,
    CREATE_PERSON_GQL,
    CREATE_PLACE_GQL,
    CREATE_PRODUCT_GQL,
    CREATE_REPO_GQL,
    CREATE_SOFTWARE_GQL,
    CREATE_SPECIFICATION_GQL,
    CREATE_WORKFLOW_GQL,
    DELETE_ALERT_GQL,
    DELETE_ALERTS_GQL,
    DELETE_ALL_ALERTS_GQL,
    DELETE_ALL_CATEGORIES_GQL,
    DELETE_ALL_COLLECTIONS_GQL,
    DELETE_ALL_CONTENTS_GQL,
    DELETE_ALL_CONVERSATIONS_GQL,
    DELETE_ALL_EVENTS_GQL,
    DELETE_ALL_FEEDS_GQL,
    DELETE_ALL_LABELS_GQL,
    DELETE_ALL_ORGANIZATIONS_GQL,
    DELETE_ALL_PERSONS_GQL,
    DELETE_ALL_PLACES_GQL,
    DELETE_ALL_PRODUCTS_GQL,
    DELETE_ALL_REPOS_GQL,
    DELETE_ALL_SOFTWARES_GQL,
    DELETE_ALL_SPECIFICATIONS_GQL,
    DELETE_ALL_WORKFLOWS_GQL,
    DELETE_CATEGORIES_GQL,
    DELETE_CATEGORY_GQL,
    DELETE_COLLECTION_GQL,
    DELETE_COLLECTIONS_GQL,
    DELETE_CONTENT_GQL,
    DELETE_CONTENTS_GQL,
    DELETE_CONVERSATION_GQL,
    DELETE_CONVERSATIONS_GQL,
    DELETE_EVENT_GQL,
    DELETE_EVENTS_GQL,
    DELETE_FEED_GQL,
    DELETE_FEEDS_GQL,
    DELETE_LABEL_GQL,
    DELETE_LABELS_GQL,
    DELETE_OBSERVATION_GQL,
    DELETE_ORGANIZATION_GQL,
    DELETE_ORGANIZATIONS_GQL,
    DELETE_PERSON_GQL,
    DELETE_PERSONS_GQL,
    DELETE_PLACE_GQL,
    DELETE_PLACES_GQL,
    DELETE_PRODUCT_GQL,
    DELETE_PRODUCTS_GQL,
    DELETE_REPO_GQL,
    DELETE_REPOS_GQL,
    DELETE_SOFTWARE_GQL,
    DELETE_SOFTWARES_GQL,
    DELETE_SPECIFICATION_GQL,
    DELETE_SPECIFICATIONS_GQL,
    DELETE_WORKFLOW_GQL,
    DELETE_WORKFLOWS_GQL,
    DISABLE_ALERT_GQL,
    DISABLE_FEED_GQL,
    ENABLE_ALERT_GQL,
    ENABLE_FEED_GQL,
    EXTRACT_CONTENTS_GQL,
    GET_ALERT_GQL,
    GET_CATEGORY_GQL,
    GET_COLLECTION_GQL,
    GET_CONTENT_GQL,
    GET_CONVERSATION_GQL,
    GET_EVENT_GQL,
    GET_FEED_GQL,
    GET_LABEL_GQL,
    GET_ORGANIZATION_GQL,
    GET_PERSON_GQL,
    GET_PLACE_GQL,
    GET_PRODUCT_GQL,
    GET_PROJECT_GQL,
    GET_REPO_GQL,
    GET_SHARE_POINT_CONSENT_URI_GQL,
    GET_SOFTWARE_GQL,
    GET_SPECIFICATION_GQL,
    GET_WORKFLOW_GQL,
    INGEST_ENCODED_FILE_GQL,
    INGEST_TEXT_GQL,
    INGEST_URI_GQL,
    IS_CONTENT_DONE_GQL,
    IS_FEED_DONE_GQL,
    LOOKUP_CREDITS_GQL,
    LOOKUP_USAGE_GQL,
    PROMPT_CONVERSATION_GQL,
    PROMPT_SPECIFICATIONS_GQL,
    PUBLISH_CONTENTS_GQL,
    PUBLISH_CONVERSATION_GQL,
    PUBLISH_TEXT_GQL,
    QUERY_ALERTS_GQL,
    QUERY_CATEGORIES_GQL,
    QUERY_COLLECTIONS_GQL,
    QUERY_CONTENTS_FACETS_GQL,
    QUERY_CONTENTS_GQL,
    QUERY_CONTENTS_GRAPH_GQL,
    QUERY_CONVERSATIONS_GQL,
    QUERY_CREDITS_GQL,
    QUERY_EVENTS_GQL,
    QUERY_FEEDS_GQL,
    QUERY_LABELS_GQL,
    QUERY_MICROSOFT_TEAMS_CHANNELS_GQL,
    QUERY_MICROSOFT_TEAMS_TEAMS_GQL,
    QUERY_ONE_DRIVE_FOLDERS_GQL,
    QUERY_ORGANIZATIONS_GQL,
    QUERY_PERSONS_GQL,
    QUERY_PLACES_GQL,
    QUERY_PRODUCTS_GQL,
    QUERY_REPOS_GQL,
    QUERY_SHARE_POINT_FOLDERS_GQL,
    QUERY_SHARE_POINT_LIBRARIES_GQL,
    QUERY_SOFTWARES_GQL,
    QUERY_SPECIFICATIONS_GQL,
    QUERY_USAGE_GQL,
    QUERY_WORKFLOWS_GQL,
    REMOVE_CONTENTS_FROM_COLLECTION_GQL,
    SUGGEST_CONVERSATION_GQL,
    SUMMARIZE_CONTENTS_GQL,
    UPDATE_ALERT_GQL,
    UPDATE_CATEGORY_GQL,
    UPDATE_COLLECTION_GQL,
    UPDATE_CONTENT_GQL,
    UPDATE_CONVERSATION_GQL,
    UPDATE_EVENT_GQL,
    UPDATE_FEED_GQL,
    UPDATE_LABEL_GQL,
    UPDATE_OBSERVATION_GQL,
    UPDATE_ORGANIZATION_GQL,
    UPDATE_PERSON_GQL,
    UPDATE_PLACE_GQL,
    UPDATE_PRODUCT_GQL,
    UPDATE_PROJECT_GQL,
    UPDATE_REPO_GQL,
    UPDATE_SOFTWARE_GQL,
    UPDATE_SPECIFICATION_GQL,
    UPDATE_WORKFLOW_GQL,
)
from .prompt_conversation import PromptConversation
from .prompt_specifications import PromptSpecifications
from .publish_contents import PublishContents
from .publish_conversation import PublishConversation
from .publish_text import PublishText
from .query_alerts import QueryAlerts
from .query_categories import QueryCategories
from .query_collections import QueryCollections
from .query_contents import QueryContents
from .query_contents_facets import QueryContentsFacets
from .query_contents_graph import QueryContentsGraph
from .query_conversations import QueryConversations
from .query_credits import QueryCredits
from .query_events import QueryEvents
from .query_feeds import QueryFeeds
from .query_labels import QueryLabels
from .query_microsoft_teams_channels import QueryMicrosoftTeamsChannels
from .query_microsoft_teams_teams import QueryMicrosoftTeamsTeams
from .query_one_drive_folders import QueryOneDriveFolders
from .query_organizations import QueryOrganizations
from .query_persons import QueryPersons
from .query_places import QueryPlaces
from .query_products import QueryProducts
from .query_repos import QueryRepos
from .query_share_point_folders import QuerySharePointFolders
from .query_share_point_libraries import QuerySharePointLibraries
from .query_softwares import QuerySoftwares
from .query_specifications import QuerySpecifications
from .query_usage import QueryUsage
from .query_workflows import QueryWorkflows
from .remove_contents_from_collection import RemoveContentsFromCollection
from .suggest_conversation import SuggestConversation
from .summarize_contents import SummarizeContents
from .update_alert import UpdateAlert
from .update_category import UpdateCategory
from .update_collection import UpdateCollection
from .update_content import UpdateContent
from .update_conversation import UpdateConversation
from .update_event import UpdateEvent
from .update_feed import UpdateFeed
from .update_label import UpdateLabel
from .update_observation import UpdateObservation
from .update_organization import UpdateOrganization
from .update_person import UpdatePerson
from .update_place import UpdatePlace
from .update_product import UpdateProduct
from .update_project import UpdateProject
from .update_repo import UpdateRepo
from .update_software import UpdateSoftware
from .update_specification import UpdateSpecification
from .update_workflow import UpdateWorkflow


def gql(q: str) -> str:
    return q


class Client(AsyncBaseClient):
    async def count_alerts(
        self, filter: Union[Optional[AlertFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> CountAlerts:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_ALERTS_GQL,
            operation_name="CountAlerts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountAlerts.model_validate(data)

    async def create_alert(
        self,
        alert: AlertInput,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CreateAlert:
        variables: Dict[str, object] = {"alert": alert, "correlationId": correlation_id}
        response = await self.execute(
            query=CREATE_ALERT_GQL,
            operation_name="CreateAlert",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateAlert.model_validate(data)

    async def delete_alert(self, id: str, **kwargs: Any) -> DeleteAlert:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_ALERT_GQL,
            operation_name="DeleteAlert",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAlert.model_validate(data)

    async def delete_alerts(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAlerts:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_ALERTS_GQL,
            operation_name="DeleteAlerts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAlerts.model_validate(data)

    async def delete_all_alerts(
        self,
        filter: Union[Optional[AlertFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllAlerts:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_ALERTS_GQL,
            operation_name="DeleteAllAlerts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllAlerts.model_validate(data)

    async def disable_alert(self, id: str, **kwargs: Any) -> DisableAlert:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DISABLE_ALERT_GQL,
            operation_name="DisableAlert",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DisableAlert.model_validate(data)

    async def enable_alert(self, id: str, **kwargs: Any) -> EnableAlert:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=ENABLE_ALERT_GQL,
            operation_name="EnableAlert",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return EnableAlert.model_validate(data)

    async def get_alert(self, id: str, **kwargs: Any) -> GetAlert:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_ALERT_GQL,
            operation_name="GetAlert",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetAlert.model_validate(data)

    async def query_alerts(
        self, filter: Union[Optional[AlertFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QueryAlerts:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_ALERTS_GQL,
            operation_name="QueryAlerts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryAlerts.model_validate(data)

    async def update_alert(self, alert: AlertUpdateInput, **kwargs: Any) -> UpdateAlert:
        variables: Dict[str, object] = {"alert": alert}
        response = await self.execute(
            query=UPDATE_ALERT_GQL,
            operation_name="UpdateAlert",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateAlert.model_validate(data)

    async def count_categories(
        self, filter: Union[Optional[CategoryFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> CountCategories:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_CATEGORIES_GQL,
            operation_name="CountCategories",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountCategories.model_validate(data)

    async def create_category(
        self, category: CategoryInput, **kwargs: Any
    ) -> CreateCategory:
        variables: Dict[str, object] = {"category": category}
        response = await self.execute(
            query=CREATE_CATEGORY_GQL,
            operation_name="CreateCategory",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateCategory.model_validate(data)

    async def delete_all_categories(
        self,
        filter: Union[Optional[CategoryFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllCategories:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_CATEGORIES_GQL,
            operation_name="DeleteAllCategories",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllCategories.model_validate(data)

    async def delete_categories(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteCategories:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_CATEGORIES_GQL,
            operation_name="DeleteCategories",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteCategories.model_validate(data)

    async def delete_category(self, id: str, **kwargs: Any) -> DeleteCategory:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_CATEGORY_GQL,
            operation_name="DeleteCategory",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteCategory.model_validate(data)

    async def get_category(self, id: str, **kwargs: Any) -> GetCategory:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_CATEGORY_GQL,
            operation_name="GetCategory",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetCategory.model_validate(data)

    async def query_categories(
        self, filter: Union[Optional[CategoryFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QueryCategories:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_CATEGORIES_GQL,
            operation_name="QueryCategories",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryCategories.model_validate(data)

    async def update_category(
        self, category: CategoryUpdateInput, **kwargs: Any
    ) -> UpdateCategory:
        variables: Dict[str, object] = {"category": category}
        response = await self.execute(
            query=UPDATE_CATEGORY_GQL,
            operation_name="UpdateCategory",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateCategory.model_validate(data)

    async def add_contents_to_collections(
        self,
        contents: List[EntityReferenceInput],
        collections: List[EntityReferenceInput],
        **kwargs: Any
    ) -> AddContentsToCollections:
        variables: Dict[str, object] = {
            "contents": contents,
            "collections": collections,
        }
        response = await self.execute(
            query=ADD_CONTENTS_TO_COLLECTIONS_GQL,
            operation_name="AddContentsToCollections",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return AddContentsToCollections.model_validate(data)

    async def count_collections(
        self,
        filter: Union[Optional[CollectionFilter], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountCollections:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_COLLECTIONS_GQL,
            operation_name="CountCollections",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountCollections.model_validate(data)

    async def create_collection(
        self, collection: CollectionInput, **kwargs: Any
    ) -> CreateCollection:
        variables: Dict[str, object] = {"collection": collection}
        response = await self.execute(
            query=CREATE_COLLECTION_GQL,
            operation_name="CreateCollection",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateCollection.model_validate(data)

    async def delete_all_collections(
        self,
        filter: Union[Optional[CollectionFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllCollections:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_COLLECTIONS_GQL,
            operation_name="DeleteAllCollections",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllCollections.model_validate(data)

    async def delete_collection(self, id: str, **kwargs: Any) -> DeleteCollection:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_COLLECTION_GQL,
            operation_name="DeleteCollection",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteCollection.model_validate(data)

    async def delete_collections(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteCollections:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_COLLECTIONS_GQL,
            operation_name="DeleteCollections",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteCollections.model_validate(data)

    async def get_collection(self, id: str, **kwargs: Any) -> GetCollection:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_COLLECTION_GQL,
            operation_name="GetCollection",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetCollection.model_validate(data)

    async def query_collections(
        self,
        filter: Union[Optional[CollectionFilter], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryCollections:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_COLLECTIONS_GQL,
            operation_name="QueryCollections",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryCollections.model_validate(data)

    async def remove_contents_from_collection(
        self,
        contents: List[EntityReferenceInput],
        collection: EntityReferenceInput,
        **kwargs: Any
    ) -> RemoveContentsFromCollection:
        variables: Dict[str, object] = {"contents": contents, "collection": collection}
        response = await self.execute(
            query=REMOVE_CONTENTS_FROM_COLLECTION_GQL,
            operation_name="RemoveContentsFromCollection",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return RemoveContentsFromCollection.model_validate(data)

    async def update_collection(
        self, collection: CollectionUpdateInput, **kwargs: Any
    ) -> UpdateCollection:
        variables: Dict[str, object] = {"collection": collection}
        response = await self.execute(
            query=UPDATE_COLLECTION_GQL,
            operation_name="UpdateCollection",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateCollection.model_validate(data)

    async def count_contents(
        self, filter: Union[Optional[ContentFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> CountContents:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_CONTENTS_GQL,
            operation_name="CountContents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountContents.model_validate(data)

    async def delete_all_contents(
        self,
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllContents:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_CONTENTS_GQL,
            operation_name="DeleteAllContents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllContents.model_validate(data)

    async def delete_content(self, id: str, **kwargs: Any) -> DeleteContent:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_CONTENT_GQL,
            operation_name="DeleteContent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteContent.model_validate(data)

    async def delete_contents(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteContents:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_CONTENTS_GQL,
            operation_name="DeleteContents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteContents.model_validate(data)

    async def extract_contents(
        self,
        prompt: str,
        specification: EntityReferenceInput,
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ExtractContents:
        variables: Dict[str, object] = {
            "prompt": prompt,
            "filter": filter,
            "specification": specification,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=EXTRACT_CONTENTS_GQL,
            operation_name="ExtractContents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ExtractContents.model_validate(data)

    async def get_content(self, id: str, **kwargs: Any) -> GetContent:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_CONTENT_GQL,
            operation_name="GetContent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetContent.model_validate(data)

    async def ingest_encoded_file(
        self,
        name: str,
        data: str,
        mime_type: str,
        id: Union[Optional[str], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        collections: Union[Optional[List[EntityReferenceInput]], UnsetType] = UNSET,
        workflow: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> IngestEncodedFile:
        variables: Dict[str, object] = {
            "name": name,
            "data": data,
            "mimeType": mime_type,
            "id": id,
            "isSynchronous": is_synchronous,
            "collections": collections,
            "workflow": workflow,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=INGEST_ENCODED_FILE_GQL,
            operation_name="IngestEncodedFile",
            variables=variables,
            **kwargs
        )
        _data = self.get_data(response)
        return IngestEncodedFile.model_validate(_data)

    async def ingest_text(
        self,
        name: str,
        text: str,
        text_type: Union[Optional[TextTypes], UnsetType] = UNSET,
        uri: Union[Optional[Any], UnsetType] = UNSET,
        id: Union[Optional[str], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        workflow: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        collections: Union[Optional[List[EntityReferenceInput]], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> IngestText:
        variables: Dict[str, object] = {
            "name": name,
            "text": text,
            "textType": text_type,
            "uri": uri,
            "id": id,
            "isSynchronous": is_synchronous,
            "workflow": workflow,
            "collections": collections,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=INGEST_TEXT_GQL,
            operation_name="IngestText",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return IngestText.model_validate(data)

    async def ingest_uri(
        self,
        uri: Any,
        name: Union[Optional[str], UnsetType] = UNSET,
        id: Union[Optional[str], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        workflow: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        collections: Union[Optional[List[EntityReferenceInput]], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> IngestUri:
        variables: Dict[str, object] = {
            "name": name,
            "uri": uri,
            "id": id,
            "isSynchronous": is_synchronous,
            "workflow": workflow,
            "collections": collections,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=INGEST_URI_GQL,
            operation_name="IngestUri",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return IngestUri.model_validate(data)

    async def is_content_done(self, id: str, **kwargs: Any) -> IsContentDone:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=IS_CONTENT_DONE_GQL,
            operation_name="IsContentDone",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return IsContentDone.model_validate(data)

    async def publish_contents(
        self,
        publish_prompt: str,
        connector: ContentPublishingConnectorInput,
        summary_prompt: Union[Optional[str], UnsetType] = UNSET,
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        name: Union[Optional[str], UnsetType] = UNSET,
        summary_specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        publish_specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        workflow: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        **kwargs: Any
    ) -> PublishContents:
        variables: Dict[str, object] = {
            "summaryPrompt": summary_prompt,
            "publishPrompt": publish_prompt,
            "connector": connector,
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
            "name": name,
            "summarySpecification": summary_specification,
            "publishSpecification": publish_specification,
            "workflow": workflow,
        }
        response = await self.execute(
            query=PUBLISH_CONTENTS_GQL,
            operation_name="PublishContents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return PublishContents.model_validate(data)

    async def publish_text(
        self,
        text: str,
        connector: ContentPublishingConnectorInput,
        text_type: Union[Optional[TextTypes], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        name: Union[Optional[str], UnsetType] = UNSET,
        workflow: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        **kwargs: Any
    ) -> PublishText:
        variables: Dict[str, object] = {
            "text": text,
            "textType": text_type,
            "connector": connector,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
            "name": name,
            "workflow": workflow,
        }
        response = await self.execute(
            query=PUBLISH_TEXT_GQL,
            operation_name="PublishText",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return PublishText.model_validate(data)

    async def query_contents(
        self, filter: Union[Optional[ContentFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QueryContents:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_CONTENTS_GQL,
            operation_name="QueryContents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryContents.model_validate(data)

    async def query_contents_facets(
        self,
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        facets: Union[Optional[List[ContentFacetInput]], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryContentsFacets:
        variables: Dict[str, object] = {"filter": filter, "facets": facets}
        response = await self.execute(
            query=QUERY_CONTENTS_FACETS_GQL,
            operation_name="QueryContentsFacets",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryContentsFacets.model_validate(data)

    async def query_contents_graph(
        self,
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        graph: Union[Optional[ContentGraphInput], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryContentsGraph:
        variables: Dict[str, object] = {"filter": filter, "graph": graph}
        response = await self.execute(
            query=QUERY_CONTENTS_GRAPH_GQL,
            operation_name="QueryContentsGraph",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryContentsGraph.model_validate(data)

    async def summarize_contents(
        self,
        summarizations: List[SummarizationStrategyInput],
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> SummarizeContents:
        variables: Dict[str, object] = {
            "summarizations": summarizations,
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=SUMMARIZE_CONTENTS_GQL,
            operation_name="SummarizeContents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return SummarizeContents.model_validate(data)

    async def update_content(
        self, content: ContentUpdateInput, **kwargs: Any
    ) -> UpdateContent:
        variables: Dict[str, object] = {"content": content}
        response = await self.execute(
            query=UPDATE_CONTENT_GQL,
            operation_name="UpdateContent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateContent.model_validate(data)

    async def clear_conversation(self, id: str, **kwargs: Any) -> ClearConversation:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=CLEAR_CONVERSATION_GQL,
            operation_name="ClearConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ClearConversation.model_validate(data)

    async def close_conversation(self, id: str, **kwargs: Any) -> CloseConversation:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=CLOSE_CONVERSATION_GQL,
            operation_name="CloseConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CloseConversation.model_validate(data)

    async def count_conversations(
        self,
        filter: Union[Optional[ConversationFilter], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountConversations:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_CONVERSATIONS_GQL,
            operation_name="CountConversations",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountConversations.model_validate(data)

    async def create_conversation(
        self,
        conversation: ConversationInput,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CreateConversation:
        variables: Dict[str, object] = {
            "conversation": conversation,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=CREATE_CONVERSATION_GQL,
            operation_name="CreateConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateConversation.model_validate(data)

    async def delete_all_conversations(
        self,
        filter: Union[Optional[ConversationFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllConversations:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_CONVERSATIONS_GQL,
            operation_name="DeleteAllConversations",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllConversations.model_validate(data)

    async def delete_conversation(self, id: str, **kwargs: Any) -> DeleteConversation:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_CONVERSATION_GQL,
            operation_name="DeleteConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteConversation.model_validate(data)

    async def delete_conversations(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteConversations:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_CONVERSATIONS_GQL,
            operation_name="DeleteConversations",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteConversations.model_validate(data)

    async def get_conversation(self, id: str, **kwargs: Any) -> GetConversation:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_CONVERSATION_GQL,
            operation_name="GetConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetConversation.model_validate(data)

    async def prompt_conversation(
        self,
        prompt: str,
        id: Union[Optional[str], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> PromptConversation:
        variables: Dict[str, object] = {
            "prompt": prompt,
            "id": id,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=PROMPT_CONVERSATION_GQL,
            operation_name="PromptConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return PromptConversation.model_validate(data)

    async def publish_conversation(
        self,
        id: str,
        connector: ContentPublishingConnectorInput,
        name: Union[Optional[str], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        workflow: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> PublishConversation:
        variables: Dict[str, object] = {
            "id": id,
            "connector": connector,
            "name": name,
            "isSynchronous": is_synchronous,
            "workflow": workflow,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=PUBLISH_CONVERSATION_GQL,
            operation_name="PublishConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return PublishConversation.model_validate(data)

    async def query_conversations(
        self,
        filter: Union[Optional[ConversationFilter], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryConversations:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_CONVERSATIONS_GQL,
            operation_name="QueryConversations",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryConversations.model_validate(data)

    async def suggest_conversation(
        self,
        id: str,
        count: Union[Optional[int], UnsetType] = UNSET,
        prompt: Union[Optional[str], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> SuggestConversation:
        variables: Dict[str, object] = {
            "id": id,
            "count": count,
            "prompt": prompt,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=SUGGEST_CONVERSATION_GQL,
            operation_name="SuggestConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return SuggestConversation.model_validate(data)

    async def update_conversation(
        self, conversation: ConversationUpdateInput, **kwargs: Any
    ) -> UpdateConversation:
        variables: Dict[str, object] = {"conversation": conversation}
        response = await self.execute(
            query=UPDATE_CONVERSATION_GQL,
            operation_name="UpdateConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateConversation.model_validate(data)

    async def count_events(
        self, filter: Union[Optional[EventFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> CountEvents:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_EVENTS_GQL,
            operation_name="CountEvents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountEvents.model_validate(data)

    async def create_event(self, event: EventInput, **kwargs: Any) -> CreateEvent:
        variables: Dict[str, object] = {"event": event}
        response = await self.execute(
            query=CREATE_EVENT_GQL,
            operation_name="CreateEvent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateEvent.model_validate(data)

    async def delete_all_events(
        self,
        filter: Union[Optional[EventFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllEvents:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_EVENTS_GQL,
            operation_name="DeleteAllEvents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllEvents.model_validate(data)

    async def delete_event(self, id: str, **kwargs: Any) -> DeleteEvent:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_EVENT_GQL,
            operation_name="DeleteEvent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteEvent.model_validate(data)

    async def delete_events(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteEvents:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_EVENTS_GQL,
            operation_name="DeleteEvents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteEvents.model_validate(data)

    async def get_event(self, id: str, **kwargs: Any) -> GetEvent:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_EVENT_GQL,
            operation_name="GetEvent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetEvent.model_validate(data)

    async def query_events(
        self, filter: Union[Optional[EventFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QueryEvents:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_EVENTS_GQL,
            operation_name="QueryEvents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryEvents.model_validate(data)

    async def update_event(self, event: EventUpdateInput, **kwargs: Any) -> UpdateEvent:
        variables: Dict[str, object] = {"event": event}
        response = await self.execute(
            query=UPDATE_EVENT_GQL,
            operation_name="UpdateEvent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateEvent.model_validate(data)

    async def count_feeds(
        self, filter: Union[Optional[FeedFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> CountFeeds:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_FEEDS_GQL,
            operation_name="CountFeeds",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountFeeds.model_validate(data)

    async def create_feed(
        self,
        feed: FeedInput,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CreateFeed:
        variables: Dict[str, object] = {"feed": feed, "correlationId": correlation_id}
        response = await self.execute(
            query=CREATE_FEED_GQL,
            operation_name="CreateFeed",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateFeed.model_validate(data)

    async def delete_all_feeds(
        self,
        filter: Union[Optional[FeedFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllFeeds:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_FEEDS_GQL,
            operation_name="DeleteAllFeeds",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllFeeds.model_validate(data)

    async def delete_feed(self, id: str, **kwargs: Any) -> DeleteFeed:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_FEED_GQL,
            operation_name="DeleteFeed",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteFeed.model_validate(data)

    async def delete_feeds(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteFeeds:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_FEEDS_GQL,
            operation_name="DeleteFeeds",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteFeeds.model_validate(data)

    async def disable_feed(self, id: str, **kwargs: Any) -> DisableFeed:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DISABLE_FEED_GQL,
            operation_name="DisableFeed",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DisableFeed.model_validate(data)

    async def enable_feed(self, id: str, **kwargs: Any) -> EnableFeed:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=ENABLE_FEED_GQL,
            operation_name="EnableFeed",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return EnableFeed.model_validate(data)

    async def get_feed(self, id: str, **kwargs: Any) -> GetFeed:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_FEED_GQL, operation_name="GetFeed", variables=variables, **kwargs
        )
        data = self.get_data(response)
        return GetFeed.model_validate(data)

    async def get_share_point_consent_uri(
        self, tenant_id: str, **kwargs: Any
    ) -> GetSharePointConsentUri:
        variables: Dict[str, object] = {"tenantId": tenant_id}
        response = await self.execute(
            query=GET_SHARE_POINT_CONSENT_URI_GQL,
            operation_name="GetSharePointConsentUri",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetSharePointConsentUri.model_validate(data)

    async def is_feed_done(self, id: str, **kwargs: Any) -> IsFeedDone:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=IS_FEED_DONE_GQL,
            operation_name="IsFeedDone",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return IsFeedDone.model_validate(data)

    async def query_feeds(
        self, filter: Union[Optional[FeedFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QueryFeeds:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_FEEDS_GQL,
            operation_name="QueryFeeds",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryFeeds.model_validate(data)

    async def query_microsoft_teams_channels(
        self, properties: MicrosoftTeamsChannelsInput, team_id: str, **kwargs: Any
    ) -> QueryMicrosoftTeamsChannels:
        variables: Dict[str, object] = {"properties": properties, "teamId": team_id}
        response = await self.execute(
            query=QUERY_MICROSOFT_TEAMS_CHANNELS_GQL,
            operation_name="QueryMicrosoftTeamsChannels",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMicrosoftTeamsChannels.model_validate(data)

    async def query_microsoft_teams_teams(
        self, properties: MicrosoftTeamsTeamsInput, **kwargs: Any
    ) -> QueryMicrosoftTeamsTeams:
        variables: Dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_MICROSOFT_TEAMS_TEAMS_GQL,
            operation_name="QueryMicrosoftTeamsTeams",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMicrosoftTeamsTeams.model_validate(data)

    async def query_one_drive_folders(
        self,
        properties: OneDriveFoldersInput,
        folder_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryOneDriveFolders:
        variables: Dict[str, object] = {"properties": properties, "folderId": folder_id}
        response = await self.execute(
            query=QUERY_ONE_DRIVE_FOLDERS_GQL,
            operation_name="QueryOneDriveFolders",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryOneDriveFolders.model_validate(data)

    async def query_share_point_folders(
        self,
        properties: SharePointFoldersInput,
        drive_id: str,
        folder_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QuerySharePointFolders:
        variables: Dict[str, object] = {
            "properties": properties,
            "driveId": drive_id,
            "folderId": folder_id,
        }
        response = await self.execute(
            query=QUERY_SHARE_POINT_FOLDERS_GQL,
            operation_name="QuerySharePointFolders",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QuerySharePointFolders.model_validate(data)

    async def query_share_point_libraries(
        self, properties: SharePointLibrariesInput, **kwargs: Any
    ) -> QuerySharePointLibraries:
        variables: Dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_SHARE_POINT_LIBRARIES_GQL,
            operation_name="QuerySharePointLibraries",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QuerySharePointLibraries.model_validate(data)

    async def update_feed(self, feed: FeedUpdateInput, **kwargs: Any) -> UpdateFeed:
        variables: Dict[str, object] = {"feed": feed}
        response = await self.execute(
            query=UPDATE_FEED_GQL,
            operation_name="UpdateFeed",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateFeed.model_validate(data)

    async def count_labels(
        self, filter: Union[Optional[LabelFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> CountLabels:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_LABELS_GQL,
            operation_name="CountLabels",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountLabels.model_validate(data)

    async def create_label(self, label: LabelInput, **kwargs: Any) -> CreateLabel:
        variables: Dict[str, object] = {"label": label}
        response = await self.execute(
            query=CREATE_LABEL_GQL,
            operation_name="CreateLabel",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateLabel.model_validate(data)

    async def delete_all_labels(
        self,
        filter: Union[Optional[LabelFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllLabels:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_LABELS_GQL,
            operation_name="DeleteAllLabels",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllLabels.model_validate(data)

    async def delete_label(self, id: str, **kwargs: Any) -> DeleteLabel:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_LABEL_GQL,
            operation_name="DeleteLabel",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteLabel.model_validate(data)

    async def delete_labels(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteLabels:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_LABELS_GQL,
            operation_name="DeleteLabels",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteLabels.model_validate(data)

    async def get_label(self, id: str, **kwargs: Any) -> GetLabel:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_LABEL_GQL,
            operation_name="GetLabel",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetLabel.model_validate(data)

    async def query_labels(
        self, filter: Union[Optional[LabelFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QueryLabels:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_LABELS_GQL,
            operation_name="QueryLabels",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryLabels.model_validate(data)

    async def update_label(self, label: LabelUpdateInput, **kwargs: Any) -> UpdateLabel:
        variables: Dict[str, object] = {"label": label}
        response = await self.execute(
            query=UPDATE_LABEL_GQL,
            operation_name="UpdateLabel",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateLabel.model_validate(data)

    async def create_observation(
        self, observation: ObservationInput, **kwargs: Any
    ) -> CreateObservation:
        variables: Dict[str, object] = {"observation": observation}
        response = await self.execute(
            query=CREATE_OBSERVATION_GQL,
            operation_name="CreateObservation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateObservation.model_validate(data)

    async def delete_observation(self, id: str, **kwargs: Any) -> DeleteObservation:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_OBSERVATION_GQL,
            operation_name="DeleteObservation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteObservation.model_validate(data)

    async def update_observation(
        self, observation: ObservationUpdateInput, **kwargs: Any
    ) -> UpdateObservation:
        variables: Dict[str, object] = {"observation": observation}
        response = await self.execute(
            query=UPDATE_OBSERVATION_GQL,
            operation_name="UpdateObservation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateObservation.model_validate(data)

    async def count_organizations(
        self,
        filter: Union[Optional[OrganizationFilter], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountOrganizations:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_ORGANIZATIONS_GQL,
            operation_name="CountOrganizations",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountOrganizations.model_validate(data)

    async def create_organization(
        self, organization: OrganizationInput, **kwargs: Any
    ) -> CreateOrganization:
        variables: Dict[str, object] = {"organization": organization}
        response = await self.execute(
            query=CREATE_ORGANIZATION_GQL,
            operation_name="CreateOrganization",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateOrganization.model_validate(data)

    async def delete_all_organizations(
        self,
        filter: Union[Optional[OrganizationFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllOrganizations:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_ORGANIZATIONS_GQL,
            operation_name="DeleteAllOrganizations",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllOrganizations.model_validate(data)

    async def delete_organization(self, id: str, **kwargs: Any) -> DeleteOrganization:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_ORGANIZATION_GQL,
            operation_name="DeleteOrganization",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteOrganization.model_validate(data)

    async def delete_organizations(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteOrganizations:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_ORGANIZATIONS_GQL,
            operation_name="DeleteOrganizations",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteOrganizations.model_validate(data)

    async def get_organization(self, id: str, **kwargs: Any) -> GetOrganization:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_ORGANIZATION_GQL,
            operation_name="GetOrganization",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetOrganization.model_validate(data)

    async def query_organizations(
        self,
        filter: Union[Optional[OrganizationFilter], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryOrganizations:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_ORGANIZATIONS_GQL,
            operation_name="QueryOrganizations",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryOrganizations.model_validate(data)

    async def update_organization(
        self, organization: OrganizationUpdateInput, **kwargs: Any
    ) -> UpdateOrganization:
        variables: Dict[str, object] = {"organization": organization}
        response = await self.execute(
            query=UPDATE_ORGANIZATION_GQL,
            operation_name="UpdateOrganization",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateOrganization.model_validate(data)

    async def count_persons(
        self, filter: Union[Optional[PersonFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> CountPersons:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_PERSONS_GQL,
            operation_name="CountPersons",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountPersons.model_validate(data)

    async def create_person(self, person: PersonInput, **kwargs: Any) -> CreatePerson:
        variables: Dict[str, object] = {"person": person}
        response = await self.execute(
            query=CREATE_PERSON_GQL,
            operation_name="CreatePerson",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreatePerson.model_validate(data)

    async def delete_all_persons(
        self,
        filter: Union[Optional[PersonFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllPersons:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_PERSONS_GQL,
            operation_name="DeleteAllPersons",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllPersons.model_validate(data)

    async def delete_person(self, id: str, **kwargs: Any) -> DeletePerson:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_PERSON_GQL,
            operation_name="DeletePerson",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeletePerson.model_validate(data)

    async def delete_persons(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeletePersons:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_PERSONS_GQL,
            operation_name="DeletePersons",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeletePersons.model_validate(data)

    async def get_person(self, id: str, **kwargs: Any) -> GetPerson:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_PERSON_GQL,
            operation_name="GetPerson",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetPerson.model_validate(data)

    async def query_persons(
        self, filter: Union[Optional[PersonFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QueryPersons:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_PERSONS_GQL,
            operation_name="QueryPersons",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryPersons.model_validate(data)

    async def update_person(
        self, person: PersonUpdateInput, **kwargs: Any
    ) -> UpdatePerson:
        variables: Dict[str, object] = {"person": person}
        response = await self.execute(
            query=UPDATE_PERSON_GQL,
            operation_name="UpdatePerson",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdatePerson.model_validate(data)

    async def count_places(
        self, filter: Union[Optional[PlaceFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> CountPlaces:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_PLACES_GQL,
            operation_name="CountPlaces",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountPlaces.model_validate(data)

    async def create_place(self, place: PlaceInput, **kwargs: Any) -> CreatePlace:
        variables: Dict[str, object] = {"place": place}
        response = await self.execute(
            query=CREATE_PLACE_GQL,
            operation_name="CreatePlace",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreatePlace.model_validate(data)

    async def delete_all_places(
        self,
        filter: Union[Optional[PlaceFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllPlaces:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_PLACES_GQL,
            operation_name="DeleteAllPlaces",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllPlaces.model_validate(data)

    async def delete_place(self, id: str, **kwargs: Any) -> DeletePlace:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_PLACE_GQL,
            operation_name="DeletePlace",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeletePlace.model_validate(data)

    async def delete_places(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeletePlaces:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_PLACES_GQL,
            operation_name="DeletePlaces",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeletePlaces.model_validate(data)

    async def get_place(self, id: str, **kwargs: Any) -> GetPlace:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_PLACE_GQL,
            operation_name="GetPlace",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetPlace.model_validate(data)

    async def query_places(
        self, filter: Union[Optional[PlaceFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QueryPlaces:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_PLACES_GQL,
            operation_name="QueryPlaces",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryPlaces.model_validate(data)

    async def update_place(self, place: PlaceUpdateInput, **kwargs: Any) -> UpdatePlace:
        variables: Dict[str, object] = {"place": place}
        response = await self.execute(
            query=UPDATE_PLACE_GQL,
            operation_name="UpdatePlace",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdatePlace.model_validate(data)

    async def count_products(
        self, filter: Union[Optional[ProductFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> CountProducts:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_PRODUCTS_GQL,
            operation_name="CountProducts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountProducts.model_validate(data)

    async def create_product(
        self, product: ProductInput, **kwargs: Any
    ) -> CreateProduct:
        variables: Dict[str, object] = {"product": product}
        response = await self.execute(
            query=CREATE_PRODUCT_GQL,
            operation_name="CreateProduct",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateProduct.model_validate(data)

    async def delete_all_products(
        self,
        filter: Union[Optional[ProductFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllProducts:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_PRODUCTS_GQL,
            operation_name="DeleteAllProducts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllProducts.model_validate(data)

    async def delete_product(self, id: str, **kwargs: Any) -> DeleteProduct:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_PRODUCT_GQL,
            operation_name="DeleteProduct",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteProduct.model_validate(data)

    async def delete_products(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteProducts:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_PRODUCTS_GQL,
            operation_name="DeleteProducts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteProducts.model_validate(data)

    async def get_product(self, id: str, **kwargs: Any) -> GetProduct:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_PRODUCT_GQL,
            operation_name="GetProduct",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetProduct.model_validate(data)

    async def query_products(
        self, filter: Union[Optional[ProductFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QueryProducts:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_PRODUCTS_GQL,
            operation_name="QueryProducts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryProducts.model_validate(data)

    async def update_product(
        self, product: ProductUpdateInput, **kwargs: Any
    ) -> UpdateProduct:
        variables: Dict[str, object] = {"product": product}
        response = await self.execute(
            query=UPDATE_PRODUCT_GQL,
            operation_name="UpdateProduct",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateProduct.model_validate(data)

    async def get_project(self, **kwargs: Any) -> GetProject:
        variables: Dict[str, object] = {}
        response = await self.execute(
            query=GET_PROJECT_GQL,
            operation_name="GetProject",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetProject.model_validate(data)

    async def lookup_credits(self, correlation_id: str, **kwargs: Any) -> LookupCredits:
        variables: Dict[str, object] = {"correlationId": correlation_id}
        response = await self.execute(
            query=LOOKUP_CREDITS_GQL,
            operation_name="LookupCredits",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return LookupCredits.model_validate(data)

    async def lookup_usage(self, correlation_id: str, **kwargs: Any) -> LookupUsage:
        variables: Dict[str, object] = {"correlationId": correlation_id}
        response = await self.execute(
            query=LOOKUP_USAGE_GQL,
            operation_name="LookupUsage",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return LookupUsage.model_validate(data)

    async def query_credits(
        self, start_date: Any, duration: Any, **kwargs: Any
    ) -> QueryCredits:
        variables: Dict[str, object] = {"startDate": start_date, "duration": duration}
        response = await self.execute(
            query=QUERY_CREDITS_GQL,
            operation_name="QueryCredits",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryCredits.model_validate(data)

    async def query_usage(
        self,
        start_date: Any,
        duration: Any,
        names: Union[Optional[List[str]], UnsetType] = UNSET,
        offset: Union[Optional[int], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryUsage:
        variables: Dict[str, object] = {
            "startDate": start_date,
            "duration": duration,
            "names": names,
            "offset": offset,
            "limit": limit,
        }
        response = await self.execute(
            query=QUERY_USAGE_GQL,
            operation_name="QueryUsage",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryUsage.model_validate(data)

    async def update_project(
        self, project: ProjectUpdateInput, **kwargs: Any
    ) -> UpdateProject:
        variables: Dict[str, object] = {"project": project}
        response = await self.execute(
            query=UPDATE_PROJECT_GQL,
            operation_name="UpdateProject",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateProject.model_validate(data)

    async def count_repos(
        self, filter: Union[Optional[RepoFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> CountRepos:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_REPOS_GQL,
            operation_name="CountRepos",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountRepos.model_validate(data)

    async def create_repo(self, repo: RepoInput, **kwargs: Any) -> CreateRepo:
        variables: Dict[str, object] = {"repo": repo}
        response = await self.execute(
            query=CREATE_REPO_GQL,
            operation_name="CreateRepo",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateRepo.model_validate(data)

    async def delete_all_repos(
        self,
        filter: Union[Optional[RepoFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllRepos:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_REPOS_GQL,
            operation_name="DeleteAllRepos",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllRepos.model_validate(data)

    async def delete_repo(self, id: str, **kwargs: Any) -> DeleteRepo:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_REPO_GQL,
            operation_name="DeleteRepo",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteRepo.model_validate(data)

    async def delete_repos(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteRepos:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_REPOS_GQL,
            operation_name="DeleteRepos",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteRepos.model_validate(data)

    async def get_repo(self, id: str, **kwargs: Any) -> GetRepo:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_REPO_GQL, operation_name="GetRepo", variables=variables, **kwargs
        )
        data = self.get_data(response)
        return GetRepo.model_validate(data)

    async def query_repos(
        self, filter: Union[Optional[RepoFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QueryRepos:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_REPOS_GQL,
            operation_name="QueryRepos",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryRepos.model_validate(data)

    async def update_repo(self, repo: RepoUpdateInput, **kwargs: Any) -> UpdateRepo:
        variables: Dict[str, object] = {"repo": repo}
        response = await self.execute(
            query=UPDATE_REPO_GQL,
            operation_name="UpdateRepo",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateRepo.model_validate(data)

    async def count_softwares(
        self, filter: Union[Optional[SoftwareFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> CountSoftwares:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_SOFTWARES_GQL,
            operation_name="CountSoftwares",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountSoftwares.model_validate(data)

    async def create_software(
        self, software: SoftwareInput, **kwargs: Any
    ) -> CreateSoftware:
        variables: Dict[str, object] = {"software": software}
        response = await self.execute(
            query=CREATE_SOFTWARE_GQL,
            operation_name="CreateSoftware",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateSoftware.model_validate(data)

    async def delete_all_softwares(
        self,
        filter: Union[Optional[SoftwareFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllSoftwares:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_SOFTWARES_GQL,
            operation_name="DeleteAllSoftwares",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllSoftwares.model_validate(data)

    async def delete_software(self, id: str, **kwargs: Any) -> DeleteSoftware:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_SOFTWARE_GQL,
            operation_name="DeleteSoftware",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteSoftware.model_validate(data)

    async def delete_softwares(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteSoftwares:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_SOFTWARES_GQL,
            operation_name="DeleteSoftwares",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteSoftwares.model_validate(data)

    async def get_software(self, id: str, **kwargs: Any) -> GetSoftware:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_SOFTWARE_GQL,
            operation_name="GetSoftware",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetSoftware.model_validate(data)

    async def query_softwares(
        self, filter: Union[Optional[SoftwareFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QuerySoftwares:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_SOFTWARES_GQL,
            operation_name="QuerySoftwares",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QuerySoftwares.model_validate(data)

    async def update_software(
        self, software: SoftwareUpdateInput, **kwargs: Any
    ) -> UpdateSoftware:
        variables: Dict[str, object] = {"software": software}
        response = await self.execute(
            query=UPDATE_SOFTWARE_GQL,
            operation_name="UpdateSoftware",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateSoftware.model_validate(data)

    async def count_specifications(
        self,
        filter: Union[Optional[SpecificationFilter], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountSpecifications:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_SPECIFICATIONS_GQL,
            operation_name="CountSpecifications",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountSpecifications.model_validate(data)

    async def create_specification(
        self, specification: SpecificationInput, **kwargs: Any
    ) -> CreateSpecification:
        variables: Dict[str, object] = {"specification": specification}
        response = await self.execute(
            query=CREATE_SPECIFICATION_GQL,
            operation_name="CreateSpecification",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateSpecification.model_validate(data)

    async def delete_all_specifications(
        self,
        filter: Union[Optional[SpecificationFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllSpecifications:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_SPECIFICATIONS_GQL,
            operation_name="DeleteAllSpecifications",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllSpecifications.model_validate(data)

    async def delete_specification(self, id: str, **kwargs: Any) -> DeleteSpecification:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_SPECIFICATION_GQL,
            operation_name="DeleteSpecification",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteSpecification.model_validate(data)

    async def delete_specifications(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteSpecifications:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_SPECIFICATIONS_GQL,
            operation_name="DeleteSpecifications",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteSpecifications.model_validate(data)

    async def get_specification(self, id: str, **kwargs: Any) -> GetSpecification:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_SPECIFICATION_GQL,
            operation_name="GetSpecification",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetSpecification.model_validate(data)

    async def prompt_specifications(
        self, prompt: str, ids: List[str], **kwargs: Any
    ) -> PromptSpecifications:
        variables: Dict[str, object] = {"prompt": prompt, "ids": ids}
        response = await self.execute(
            query=PROMPT_SPECIFICATIONS_GQL,
            operation_name="PromptSpecifications",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return PromptSpecifications.model_validate(data)

    async def query_specifications(
        self,
        filter: Union[Optional[SpecificationFilter], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QuerySpecifications:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_SPECIFICATIONS_GQL,
            operation_name="QuerySpecifications",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QuerySpecifications.model_validate(data)

    async def update_specification(
        self, specification: SpecificationUpdateInput, **kwargs: Any
    ) -> UpdateSpecification:
        variables: Dict[str, object] = {"specification": specification}
        response = await self.execute(
            query=UPDATE_SPECIFICATION_GQL,
            operation_name="UpdateSpecification",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateSpecification.model_validate(data)

    async def count_workflows(
        self, filter: Union[Optional[WorkflowFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> CountWorkflows:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=COUNT_WORKFLOWS_GQL,
            operation_name="CountWorkflows",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountWorkflows.model_validate(data)

    async def create_workflow(
        self, workflow: WorkflowInput, **kwargs: Any
    ) -> CreateWorkflow:
        variables: Dict[str, object] = {"workflow": workflow}
        response = await self.execute(
            query=CREATE_WORKFLOW_GQL,
            operation_name="CreateWorkflow",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateWorkflow.model_validate(data)

    async def delete_all_workflows(
        self,
        filter: Union[Optional[WorkflowFilter], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAllWorkflows:
        variables: Dict[str, object] = {
            "filter": filter,
            "isSynchronous": is_synchronous,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DELETE_ALL_WORKFLOWS_GQL,
            operation_name="DeleteAllWorkflows",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAllWorkflows.model_validate(data)

    async def delete_workflow(self, id: str, **kwargs: Any) -> DeleteWorkflow:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=DELETE_WORKFLOW_GQL,
            operation_name="DeleteWorkflow",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteWorkflow.model_validate(data)

    async def delete_workflows(
        self,
        ids: List[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteWorkflows:
        variables: Dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_WORKFLOWS_GQL,
            operation_name="DeleteWorkflows",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteWorkflows.model_validate(data)

    async def get_workflow(self, id: str, **kwargs: Any) -> GetWorkflow:
        variables: Dict[str, object] = {"id": id}
        response = await self.execute(
            query=GET_WORKFLOW_GQL,
            operation_name="GetWorkflow",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetWorkflow.model_validate(data)

    async def query_workflows(
        self, filter: Union[Optional[WorkflowFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QueryWorkflows:
        variables: Dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_WORKFLOWS_GQL,
            operation_name="QueryWorkflows",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryWorkflows.model_validate(data)

    async def update_workflow(
        self, workflow: WorkflowUpdateInput, **kwargs: Any
    ) -> UpdateWorkflow:
        variables: Dict[str, object] = {"workflow": workflow}
        response = await self.execute(
            query=UPDATE_WORKFLOW_GQL,
            operation_name="UpdateWorkflow",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateWorkflow.model_validate(data)
