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

from typing import Any, Optional, Union

from .add_contents_to_collections import AddContentsToCollections
from .add_conversations_to_collections import AddConversationsToCollections
from .approve_content import ApproveContent
from .ask_graphlit import AskGraphlit
from .async_base_client import AsyncBaseClient
from .base_model import UNSET, UnsetType
from .branch_conversation import BranchConversation
from .clear_conversation import ClearConversation
from .close_conversation import CloseConversation
from .complete_conversation import CompleteConversation
from .continue_conversation import ContinueConversation
from .count_agents import CountAgents
from .count_alerts import CountAlerts
from .count_categories import CountCategories
from .count_collections import CountCollections
from .count_connectors import CountConnectors
from .count_contents import CountContents
from .count_conversations import CountConversations
from .count_emotions import CountEmotions
from .count_events import CountEvents
from .count_facts import CountFacts
from .count_feeds import CountFeeds
from .count_investment_funds import CountInvestmentFunds
from .count_investments import CountInvestments
from .count_labels import CountLabels
from .count_medical_conditions import CountMedicalConditions
from .count_medical_contraindications import CountMedicalContraindications
from .count_medical_devices import CountMedicalDevices
from .count_medical_drug_classes import CountMedicalDrugClasses
from .count_medical_drugs import CountMedicalDrugs
from .count_medical_guidelines import CountMedicalGuidelines
from .count_medical_indications import CountMedicalIndications
from .count_medical_procedures import CountMedicalProcedures
from .count_medical_studies import CountMedicalStudies
from .count_medical_tests import CountMedicalTests
from .count_medical_therapies import CountMedicalTherapies
from .count_organizations import CountOrganizations
from .count_personas import CountPersonas
from .count_persons import CountPersons
from .count_places import CountPlaces
from .count_products import CountProducts
from .count_repos import CountRepos
from .count_skills import CountSkills
from .count_softwares import CountSoftwares
from .count_specifications import CountSpecifications
from .count_users import CountUsers
from .count_views import CountViews
from .count_workflows import CountWorkflows
from .create_agent import CreateAgent
from .create_alert import CreateAlert
from .create_category import CreateCategory
from .create_collection import CreateCollection
from .create_connector import CreateConnector
from .create_conversation import CreateConversation
from .create_emotion import CreateEmotion
from .create_event import CreateEvent
from .create_fact import CreateFact
from .create_feed import CreateFeed
from .create_investment import CreateInvestment
from .create_investment_fund import CreateInvestmentFund
from .create_label import CreateLabel
from .create_medical_condition import CreateMedicalCondition
from .create_medical_contraindication import CreateMedicalContraindication
from .create_medical_device import CreateMedicalDevice
from .create_medical_drug import CreateMedicalDrug
from .create_medical_drug_class import CreateMedicalDrugClass
from .create_medical_guideline import CreateMedicalGuideline
from .create_medical_indication import CreateMedicalIndication
from .create_medical_procedure import CreateMedicalProcedure
from .create_medical_study import CreateMedicalStudy
from .create_medical_test import CreateMedicalTest
from .create_medical_therapy import CreateMedicalTherapy
from .create_observation import CreateObservation
from .create_organization import CreateOrganization
from .create_person import CreatePerson
from .create_persona import CreatePersona
from .create_place import CreatePlace
from .create_product import CreateProduct
from .create_repo import CreateRepo
from .create_skill import CreateSkill
from .create_software import CreateSoftware
from .create_specification import CreateSpecification
from .create_user import CreateUser
from .create_view import CreateView
from .create_workflow import CreateWorkflow
from .delete_agent import DeleteAgent
from .delete_agents import DeleteAgents
from .delete_alert import DeleteAlert
from .delete_alerts import DeleteAlerts
from .delete_all_agents import DeleteAllAgents
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_emotions import DeleteAllEmotions
from .delete_all_events import DeleteAllEvents
from .delete_all_facts import DeleteAllFacts
from .delete_all_feeds import DeleteAllFeeds
from .delete_all_investment_funds import DeleteAllInvestmentFunds
from .delete_all_investments import DeleteAllInvestments
from .delete_all_labels import DeleteAllLabels
from .delete_all_medical_conditions import DeleteAllMedicalConditions
from .delete_all_medical_contraindications import DeleteAllMedicalContraindications
from .delete_all_medical_devices import DeleteAllMedicalDevices
from .delete_all_medical_drug_classes import DeleteAllMedicalDrugClasses
from .delete_all_medical_drugs import DeleteAllMedicalDrugs
from .delete_all_medical_guidelines import DeleteAllMedicalGuidelines
from .delete_all_medical_indications import DeleteAllMedicalIndications
from .delete_all_medical_procedures import DeleteAllMedicalProcedures
from .delete_all_medical_studies import DeleteAllMedicalStudies
from .delete_all_medical_tests import DeleteAllMedicalTests
from .delete_all_medical_therapies import DeleteAllMedicalTherapies
from .delete_all_organizations import DeleteAllOrganizations
from .delete_all_personas import DeleteAllPersonas
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_skills import DeleteAllSkills
from .delete_all_softwares import DeleteAllSoftwares
from .delete_all_specifications import DeleteAllSpecifications
from .delete_all_views import DeleteAllViews
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_connector import DeleteConnector
from .delete_content import DeleteContent
from .delete_contents import DeleteContents
from .delete_conversation import DeleteConversation
from .delete_conversations import DeleteConversations
from .delete_emotion import DeleteEmotion
from .delete_emotions import DeleteEmotions
from .delete_event import DeleteEvent
from .delete_events import DeleteEvents
from .delete_fact import DeleteFact
from .delete_facts import DeleteFacts
from .delete_feed import DeleteFeed
from .delete_feeds import DeleteFeeds
from .delete_investment import DeleteInvestment
from .delete_investment_fund import DeleteInvestmentFund
from .delete_investment_funds import DeleteInvestmentFunds
from .delete_investments import DeleteInvestments
from .delete_label import DeleteLabel
from .delete_labels import DeleteLabels
from .delete_medical_condition import DeleteMedicalCondition
from .delete_medical_conditions import DeleteMedicalConditions
from .delete_medical_contraindication import DeleteMedicalContraindication
from .delete_medical_contraindications import DeleteMedicalContraindications
from .delete_medical_device import DeleteMedicalDevice
from .delete_medical_devices import DeleteMedicalDevices
from .delete_medical_drug import DeleteMedicalDrug
from .delete_medical_drug_class import DeleteMedicalDrugClass
from .delete_medical_drug_classes import DeleteMedicalDrugClasses
from .delete_medical_drugs import DeleteMedicalDrugs
from .delete_medical_guideline import DeleteMedicalGuideline
from .delete_medical_guidelines import DeleteMedicalGuidelines
from .delete_medical_indication import DeleteMedicalIndication
from .delete_medical_indications import DeleteMedicalIndications
from .delete_medical_procedure import DeleteMedicalProcedure
from .delete_medical_procedures import DeleteMedicalProcedures
from .delete_medical_studies import DeleteMedicalStudies
from .delete_medical_study import DeleteMedicalStudy
from .delete_medical_test import DeleteMedicalTest
from .delete_medical_tests import DeleteMedicalTests
from .delete_medical_therapies import DeleteMedicalTherapies
from .delete_medical_therapy import DeleteMedicalTherapy
from .delete_observation import DeleteObservation
from .delete_organization import DeleteOrganization
from .delete_organizations import DeleteOrganizations
from .delete_person import DeletePerson
from .delete_persona import DeletePersona
from .delete_personas import DeletePersonas
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_skill import DeleteSkill
from .delete_skills import DeleteSkills
from .delete_software import DeleteSoftware
from .delete_softwares import DeleteSoftwares
from .delete_specification import DeleteSpecification
from .delete_specifications import DeleteSpecifications
from .delete_user import DeleteUser
from .delete_view import DeleteView
from .delete_views import DeleteViews
from .delete_workflow import DeleteWorkflow
from .delete_workflows import DeleteWorkflows
from .describe_encoded_image import DescribeEncodedImage
from .describe_image import DescribeImage
from .disable_agent import DisableAgent
from .disable_alert import DisableAlert
from .disable_feed import DisableFeed
from .disable_skill import DisableSkill
from .disable_user import DisableUser
from .distribute import Distribute
from .enable_agent import EnableAgent
from .enable_alert import EnableAlert
from .enable_feed import EnableFeed
from .enable_skill import EnableSkill
from .enable_user import EnableUser
from .enrich_organizations import EnrichOrganizations
from .enrich_persons import EnrichPersons
from .enrich_places import EnrichPlaces
from .enrich_products import EnrichProducts
from .enums import (
    GitHubRepositorySortTypes,
    ObservableTypes,
    SdkTypes,
    SearchServiceTypes,
    SearchTypes,
    TextTypes,
)
from .extract_contents import ExtractContents
from .extract_observables import ExtractObservables
from .extract_text import ExtractText
from .feed_exists import FeedExists
from .format_conversation import FormatConversation
from .get_agent import GetAgent
from .get_alert import GetAlert
from .get_category import GetCategory
from .get_collection import GetCollection
from .get_connector import GetConnector
from .get_content import GetContent
from .get_conversation import GetConversation
from .get_emotion import GetEmotion
from .get_event import GetEvent
from .get_fact import GetFact
from .get_feed import GetFeed
from .get_investment import GetInvestment
from .get_investment_fund import GetInvestmentFund
from .get_label import GetLabel
from .get_medical_condition import GetMedicalCondition
from .get_medical_contraindication import GetMedicalContraindication
from .get_medical_device import GetMedicalDevice
from .get_medical_drug import GetMedicalDrug
from .get_medical_drug_class import GetMedicalDrugClass
from .get_medical_guideline import GetMedicalGuideline
from .get_medical_indication import GetMedicalIndication
from .get_medical_procedure import GetMedicalProcedure
from .get_medical_study import GetMedicalStudy
from .get_medical_test import GetMedicalTest
from .get_medical_therapy import GetMedicalTherapy
from .get_organization import GetOrganization
from .get_person import GetPerson
from .get_persona import GetPersona
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_skill import GetSkill
from .get_software import GetSoftware
from .get_specification import GetSpecification
from .get_user import GetUser
from .get_user_by_identifier import GetUserByIdentifier
from .get_view import GetView
from .get_workflow import GetWorkflow
from .ingest_batch import IngestBatch
from .ingest_encoded_file import IngestEncodedFile
from .ingest_event import IngestEvent
from .ingest_memory import IngestMemory
from .ingest_text import IngestText
from .ingest_text_batch import IngestTextBatch
from .ingest_uri import IngestUri
from .input_types import (
    AgentFilter,
    AgentInput,
    AgentUpdateInput,
    AlertFilter,
    AlertInput,
    AlertUpdateInput,
    AsanaProjectsInput,
    AsanaWorkspacesInput,
    AtlassianSitesInput,
    BambooHROptionsInput,
    BoxFoldersInput,
    CategoryFilter,
    CategoryInput,
    CategoryUpdateInput,
    CollectionFilter,
    CollectionInput,
    CollectionUpdateInput,
    ConfluenceSpacesInput,
    ConnectorFilter,
    ConnectorInput,
    ConnectorUpdateInput,
    ContentFacetInput,
    ContentFilter,
    ContentGraphInput,
    ContentPublishingConnectorInput,
    ContentUpdateInput,
    ConversationFilter,
    ConversationGraphInput,
    ConversationInput,
    ConversationMessageInput,
    ConversationToolResponseInput,
    ConversationUpdateInput,
    DiscordChannelsInput,
    DiscordGuildsInput,
    DistributionConnectorInput,
    DropboxFoldersInput,
    EmotionFilter,
    EmotionInput,
    EmotionUpdateInput,
    EntityClustersInput,
    EntityEnrichmentConnectorInput,
    EntityReferenceInput,
    EntityRelationshipsFilter,
    EventFilter,
    EventInput,
    EventUpdateInput,
    FactFilter,
    FactGraphInput,
    FactInput,
    FactUpdateInput,
    FeedFilter,
    FeedInput,
    FeedUpdateInput,
    GitHubRepositoriesInput,
    GoogleCalendarsInput,
    GoogleDriveDrivesInput,
    GoogleDriveFoldersInput,
    GraphFilter,
    GraphInput,
    GustoCompaniesInput,
    GustoOptionsInput,
    IntegrationConnectorInput,
    InvestmentFilter,
    InvestmentFundFilter,
    InvestmentFundInput,
    InvestmentFundUpdateInput,
    InvestmentInput,
    InvestmentUpdateInput,
    JiraProjectsInput,
    LabelFilter,
    LabelInput,
    LabelUpdateInput,
    LinearProjectsInput,
    MedicalConditionFilter,
    MedicalConditionInput,
    MedicalConditionUpdateInput,
    MedicalContraindicationFilter,
    MedicalContraindicationInput,
    MedicalContraindicationUpdateInput,
    MedicalDeviceFilter,
    MedicalDeviceInput,
    MedicalDeviceUpdateInput,
    MedicalDrugClassFilter,
    MedicalDrugClassInput,
    MedicalDrugClassUpdateInput,
    MedicalDrugFilter,
    MedicalDrugInput,
    MedicalDrugUpdateInput,
    MedicalGuidelineFilter,
    MedicalGuidelineInput,
    MedicalGuidelineUpdateInput,
    MedicalIndicationFilter,
    MedicalIndicationInput,
    MedicalIndicationUpdateInput,
    MedicalProcedureFilter,
    MedicalProcedureInput,
    MedicalProcedureUpdateInput,
    MedicalStudyFilter,
    MedicalStudyInput,
    MedicalStudyUpdateInput,
    MedicalTestFilter,
    MedicalTestInput,
    MedicalTestUpdateInput,
    MedicalTherapyFilter,
    MedicalTherapyInput,
    MedicalTherapyUpdateInput,
    MicrosoftCalendarsInput,
    MicrosoftTeamsChannelsInput,
    MicrosoftTeamsTeamsInput,
    ModelFilter,
    MondayBoardsInput,
    NotionDatabasesInput,
    NotionPagesInput,
    ObservableInput,
    ObservationInput,
    ObservationReferenceInput,
    ObservationUpdateInput,
    OneDriveFoldersInput,
    OrganizationFilter,
    OrganizationInput,
    OrganizationUpdateInput,
    PersonaFilter,
    PersonaInput,
    PersonaUpdateInput,
    PersonFilter,
    PersonInput,
    PersonUpdateInput,
    PlaceFilter,
    PlaceInput,
    PlaceUpdateInput,
    ProductFilter,
    ProductInput,
    ProductUpdateInput,
    ProjectUpdateInput,
    RepoFilter,
    RepoInput,
    RepoUpdateInput,
    RerankingStrategyInput,
    RetrievalStrategyInput,
    SharePointFoldersInput,
    SharePointLibrariesInput,
    SkillFilter,
    SkillInput,
    SkillUpdateInput,
    SlackChannelsInput,
    SoftwareFilter,
    SoftwareInput,
    SoftwareUpdateInput,
    SpecificationFilter,
    SpecificationInput,
    SpecificationUpdateInput,
    SummarizationStrategyInput,
    TextContentInput,
    ToolDefinitionInput,
    UserFilter,
    UserInput,
    UserUpdateInput,
    ViewFilter,
    ViewInput,
    ViewUpdateInput,
    WorkflowFilter,
    WorkflowInput,
    WorkflowUpdateInput,
)
from .is_content_done import IsContentDone
from .is_feed_done import IsFeedDone
from .lookup_companies import LookupCompanies
from .lookup_contents import LookupContents
from .lookup_credits import LookupCredits
from .lookup_entity import LookupEntity
from .lookup_persons import LookupPersons
from .lookup_usage import LookupUsage
from .map_web import MapWeb
from .match_entity import MatchEntity
from .operations import (
    ADD_CONTENTS_TO_COLLECTIONS_GQL,
    ADD_CONVERSATIONS_TO_COLLECTIONS_GQL,
    APPROVE_CONTENT_GQL,
    ASK_GRAPHLIT_GQL,
    BRANCH_CONVERSATION_GQL,
    CLEAR_CONVERSATION_GQL,
    CLOSE_CONVERSATION_GQL,
    COMPLETE_CONVERSATION_GQL,
    CONTINUE_CONVERSATION_GQL,
    COUNT_AGENTS_GQL,
    COUNT_ALERTS_GQL,
    COUNT_CATEGORIES_GQL,
    COUNT_COLLECTIONS_GQL,
    COUNT_CONNECTORS_GQL,
    COUNT_CONTENTS_GQL,
    COUNT_CONVERSATIONS_GQL,
    COUNT_EMOTIONS_GQL,
    COUNT_EVENTS_GQL,
    COUNT_FACTS_GQL,
    COUNT_FEEDS_GQL,
    COUNT_INVESTMENT_FUNDS_GQL,
    COUNT_INVESTMENTS_GQL,
    COUNT_LABELS_GQL,
    COUNT_MEDICAL_CONDITIONS_GQL,
    COUNT_MEDICAL_CONTRAINDICATIONS_GQL,
    COUNT_MEDICAL_DEVICES_GQL,
    COUNT_MEDICAL_DRUG_CLASSES_GQL,
    COUNT_MEDICAL_DRUGS_GQL,
    COUNT_MEDICAL_GUIDELINES_GQL,
    COUNT_MEDICAL_INDICATIONS_GQL,
    COUNT_MEDICAL_PROCEDURES_GQL,
    COUNT_MEDICAL_STUDIES_GQL,
    COUNT_MEDICAL_TESTS_GQL,
    COUNT_MEDICAL_THERAPIES_GQL,
    COUNT_ORGANIZATIONS_GQL,
    COUNT_PERSONAS_GQL,
    COUNT_PERSONS_GQL,
    COUNT_PLACES_GQL,
    COUNT_PRODUCTS_GQL,
    COUNT_REPOS_GQL,
    COUNT_SKILLS_GQL,
    COUNT_SOFTWARES_GQL,
    COUNT_SPECIFICATIONS_GQL,
    COUNT_USERS_GQL,
    COUNT_VIEWS_GQL,
    COUNT_WORKFLOWS_GQL,
    CREATE_AGENT_GQL,
    CREATE_ALERT_GQL,
    CREATE_CATEGORY_GQL,
    CREATE_COLLECTION_GQL,
    CREATE_CONNECTOR_GQL,
    CREATE_CONVERSATION_GQL,
    CREATE_EMOTION_GQL,
    CREATE_EVENT_GQL,
    CREATE_FACT_GQL,
    CREATE_FEED_GQL,
    CREATE_INVESTMENT_FUND_GQL,
    CREATE_INVESTMENT_GQL,
    CREATE_LABEL_GQL,
    CREATE_MEDICAL_CONDITION_GQL,
    CREATE_MEDICAL_CONTRAINDICATION_GQL,
    CREATE_MEDICAL_DEVICE_GQL,
    CREATE_MEDICAL_DRUG_CLASS_GQL,
    CREATE_MEDICAL_DRUG_GQL,
    CREATE_MEDICAL_GUIDELINE_GQL,
    CREATE_MEDICAL_INDICATION_GQL,
    CREATE_MEDICAL_PROCEDURE_GQL,
    CREATE_MEDICAL_STUDY_GQL,
    CREATE_MEDICAL_TEST_GQL,
    CREATE_MEDICAL_THERAPY_GQL,
    CREATE_OBSERVATION_GQL,
    CREATE_ORGANIZATION_GQL,
    CREATE_PERSON_GQL,
    CREATE_PERSONA_GQL,
    CREATE_PLACE_GQL,
    CREATE_PRODUCT_GQL,
    CREATE_REPO_GQL,
    CREATE_SKILL_GQL,
    CREATE_SOFTWARE_GQL,
    CREATE_SPECIFICATION_GQL,
    CREATE_USER_GQL,
    CREATE_VIEW_GQL,
    CREATE_WORKFLOW_GQL,
    DELETE_AGENT_GQL,
    DELETE_AGENTS_GQL,
    DELETE_ALERT_GQL,
    DELETE_ALERTS_GQL,
    DELETE_ALL_AGENTS_GQL,
    DELETE_ALL_ALERTS_GQL,
    DELETE_ALL_CATEGORIES_GQL,
    DELETE_ALL_COLLECTIONS_GQL,
    DELETE_ALL_CONTENTS_GQL,
    DELETE_ALL_CONVERSATIONS_GQL,
    DELETE_ALL_EMOTIONS_GQL,
    DELETE_ALL_EVENTS_GQL,
    DELETE_ALL_FACTS_GQL,
    DELETE_ALL_FEEDS_GQL,
    DELETE_ALL_INVESTMENT_FUNDS_GQL,
    DELETE_ALL_INVESTMENTS_GQL,
    DELETE_ALL_LABELS_GQL,
    DELETE_ALL_MEDICAL_CONDITIONS_GQL,
    DELETE_ALL_MEDICAL_CONTRAINDICATIONS_GQL,
    DELETE_ALL_MEDICAL_DEVICES_GQL,
    DELETE_ALL_MEDICAL_DRUG_CLASSES_GQL,
    DELETE_ALL_MEDICAL_DRUGS_GQL,
    DELETE_ALL_MEDICAL_GUIDELINES_GQL,
    DELETE_ALL_MEDICAL_INDICATIONS_GQL,
    DELETE_ALL_MEDICAL_PROCEDURES_GQL,
    DELETE_ALL_MEDICAL_STUDIES_GQL,
    DELETE_ALL_MEDICAL_TESTS_GQL,
    DELETE_ALL_MEDICAL_THERAPIES_GQL,
    DELETE_ALL_ORGANIZATIONS_GQL,
    DELETE_ALL_PERSONAS_GQL,
    DELETE_ALL_PERSONS_GQL,
    DELETE_ALL_PLACES_GQL,
    DELETE_ALL_PRODUCTS_GQL,
    DELETE_ALL_REPOS_GQL,
    DELETE_ALL_SKILLS_GQL,
    DELETE_ALL_SOFTWARES_GQL,
    DELETE_ALL_SPECIFICATIONS_GQL,
    DELETE_ALL_VIEWS_GQL,
    DELETE_ALL_WORKFLOWS_GQL,
    DELETE_CATEGORIES_GQL,
    DELETE_CATEGORY_GQL,
    DELETE_COLLECTION_GQL,
    DELETE_COLLECTIONS_GQL,
    DELETE_CONNECTOR_GQL,
    DELETE_CONTENT_GQL,
    DELETE_CONTENTS_GQL,
    DELETE_CONVERSATION_GQL,
    DELETE_CONVERSATIONS_GQL,
    DELETE_EMOTION_GQL,
    DELETE_EMOTIONS_GQL,
    DELETE_EVENT_GQL,
    DELETE_EVENTS_GQL,
    DELETE_FACT_GQL,
    DELETE_FACTS_GQL,
    DELETE_FEED_GQL,
    DELETE_FEEDS_GQL,
    DELETE_INVESTMENT_FUND_GQL,
    DELETE_INVESTMENT_FUNDS_GQL,
    DELETE_INVESTMENT_GQL,
    DELETE_INVESTMENTS_GQL,
    DELETE_LABEL_GQL,
    DELETE_LABELS_GQL,
    DELETE_MEDICAL_CONDITION_GQL,
    DELETE_MEDICAL_CONDITIONS_GQL,
    DELETE_MEDICAL_CONTRAINDICATION_GQL,
    DELETE_MEDICAL_CONTRAINDICATIONS_GQL,
    DELETE_MEDICAL_DEVICE_GQL,
    DELETE_MEDICAL_DEVICES_GQL,
    DELETE_MEDICAL_DRUG_CLASS_GQL,
    DELETE_MEDICAL_DRUG_CLASSES_GQL,
    DELETE_MEDICAL_DRUG_GQL,
    DELETE_MEDICAL_DRUGS_GQL,
    DELETE_MEDICAL_GUIDELINE_GQL,
    DELETE_MEDICAL_GUIDELINES_GQL,
    DELETE_MEDICAL_INDICATION_GQL,
    DELETE_MEDICAL_INDICATIONS_GQL,
    DELETE_MEDICAL_PROCEDURE_GQL,
    DELETE_MEDICAL_PROCEDURES_GQL,
    DELETE_MEDICAL_STUDIES_GQL,
    DELETE_MEDICAL_STUDY_GQL,
    DELETE_MEDICAL_TEST_GQL,
    DELETE_MEDICAL_TESTS_GQL,
    DELETE_MEDICAL_THERAPIES_GQL,
    DELETE_MEDICAL_THERAPY_GQL,
    DELETE_OBSERVATION_GQL,
    DELETE_ORGANIZATION_GQL,
    DELETE_ORGANIZATIONS_GQL,
    DELETE_PERSON_GQL,
    DELETE_PERSONA_GQL,
    DELETE_PERSONAS_GQL,
    DELETE_PERSONS_GQL,
    DELETE_PLACE_GQL,
    DELETE_PLACES_GQL,
    DELETE_PRODUCT_GQL,
    DELETE_PRODUCTS_GQL,
    DELETE_REPO_GQL,
    DELETE_REPOS_GQL,
    DELETE_SKILL_GQL,
    DELETE_SKILLS_GQL,
    DELETE_SOFTWARE_GQL,
    DELETE_SOFTWARES_GQL,
    DELETE_SPECIFICATION_GQL,
    DELETE_SPECIFICATIONS_GQL,
    DELETE_USER_GQL,
    DELETE_VIEW_GQL,
    DELETE_VIEWS_GQL,
    DELETE_WORKFLOW_GQL,
    DELETE_WORKFLOWS_GQL,
    DESCRIBE_ENCODED_IMAGE_GQL,
    DESCRIBE_IMAGE_GQL,
    DISABLE_AGENT_GQL,
    DISABLE_ALERT_GQL,
    DISABLE_FEED_GQL,
    DISABLE_SKILL_GQL,
    DISABLE_USER_GQL,
    DISTRIBUTE_GQL,
    ENABLE_AGENT_GQL,
    ENABLE_ALERT_GQL,
    ENABLE_FEED_GQL,
    ENABLE_SKILL_GQL,
    ENABLE_USER_GQL,
    ENRICH_ORGANIZATIONS_GQL,
    ENRICH_PERSONS_GQL,
    ENRICH_PLACES_GQL,
    ENRICH_PRODUCTS_GQL,
    EXTRACT_CONTENTS_GQL,
    EXTRACT_OBSERVABLES_GQL,
    EXTRACT_TEXT_GQL,
    FEED_EXISTS_GQL,
    FORMAT_CONVERSATION_GQL,
    GET_AGENT_GQL,
    GET_ALERT_GQL,
    GET_CATEGORY_GQL,
    GET_COLLECTION_GQL,
    GET_CONNECTOR_GQL,
    GET_CONTENT_GQL,
    GET_CONVERSATION_GQL,
    GET_EMOTION_GQL,
    GET_EVENT_GQL,
    GET_FACT_GQL,
    GET_FEED_GQL,
    GET_INVESTMENT_FUND_GQL,
    GET_INVESTMENT_GQL,
    GET_LABEL_GQL,
    GET_MEDICAL_CONDITION_GQL,
    GET_MEDICAL_CONTRAINDICATION_GQL,
    GET_MEDICAL_DEVICE_GQL,
    GET_MEDICAL_DRUG_CLASS_GQL,
    GET_MEDICAL_DRUG_GQL,
    GET_MEDICAL_GUIDELINE_GQL,
    GET_MEDICAL_INDICATION_GQL,
    GET_MEDICAL_PROCEDURE_GQL,
    GET_MEDICAL_STUDY_GQL,
    GET_MEDICAL_TEST_GQL,
    GET_MEDICAL_THERAPY_GQL,
    GET_ORGANIZATION_GQL,
    GET_PERSON_GQL,
    GET_PERSONA_GQL,
    GET_PLACE_GQL,
    GET_PRODUCT_GQL,
    GET_PROJECT_GQL,
    GET_REPO_GQL,
    GET_SHARE_POINT_CONSENT_URI_GQL,
    GET_SKILL_GQL,
    GET_SOFTWARE_GQL,
    GET_SPECIFICATION_GQL,
    GET_USER_BY_IDENTIFIER_GQL,
    GET_USER_GQL,
    GET_VIEW_GQL,
    GET_WORKFLOW_GQL,
    INGEST_BATCH_GQL,
    INGEST_ENCODED_FILE_GQL,
    INGEST_EVENT_GQL,
    INGEST_MEMORY_GQL,
    INGEST_TEXT_BATCH_GQL,
    INGEST_TEXT_GQL,
    INGEST_URI_GQL,
    IS_CONTENT_DONE_GQL,
    IS_FEED_DONE_GQL,
    LOOKUP_COMPANIES_GQL,
    LOOKUP_CONTENTS_GQL,
    LOOKUP_CREDITS_GQL,
    LOOKUP_ENTITY_GQL,
    LOOKUP_PERSONS_GQL,
    LOOKUP_USAGE_GQL,
    MAP_WEB_GQL,
    MATCH_ENTITY_GQL,
    PROMPT_CONVERSATION_GQL,
    PROMPT_GQL,
    PROMPT_SPECIFICATIONS_GQL,
    PUBLISH_CONTENTS_GQL,
    PUBLISH_CONVERSATION_GQL,
    PUBLISH_TEXT_GQL,
    QUERY_AGENTS_GQL,
    QUERY_ALERTS_GQL,
    QUERY_ASANA_PROJECTS_GQL,
    QUERY_ASANA_WORKSPACES_GQL,
    QUERY_ATLASSIAN_SITES_GQL,
    QUERY_BAMBOO_HR_DEPARTMENTS_GQL,
    QUERY_BAMBOO_HR_DIVISIONS_GQL,
    QUERY_BAMBOO_HR_EMPLOYMENT_STATUSES_GQL,
    QUERY_BAMBOO_HR_LOCATIONS_GQL,
    QUERY_BOX_FOLDERS_GQL,
    QUERY_CATEGORIES_GQL,
    QUERY_COLLECTIONS_GQL,
    QUERY_CONFLUENCE_SPACES_GQL,
    QUERY_CONNECTORS_GQL,
    QUERY_CONTENTS_FACETS_GQL,
    QUERY_CONTENTS_GQL,
    QUERY_CONTENTS_GRAPH_GQL,
    QUERY_CONTENTS_OBSERVATIONS_GQL,
    QUERY_CONVERSATIONS_CLUSTERS_GQL,
    QUERY_CONVERSATIONS_GQL,
    QUERY_CONVERSATIONS_GRAPH_GQL,
    QUERY_CREDITS_GQL,
    QUERY_DISCORD_CHANNELS_GQL,
    QUERY_DISCORD_GUILDS_GQL,
    QUERY_DROPBOX_FOLDERS_GQL,
    QUERY_EMOTIONS_GQL,
    QUERY_EVENTS_CLUSTERS_GQL,
    QUERY_EVENTS_GQL,
    QUERY_FACTS_CLUSTERS_GQL,
    QUERY_FACTS_GQL,
    QUERY_FACTS_GRAPH_GQL,
    QUERY_FEEDS_GQL,
    QUERY_GIT_HUB_REPOSITORIES_GQL,
    QUERY_GOOGLE_CALENDARS_GQL,
    QUERY_GOOGLE_DRIVE_DRIVES_GQL,
    QUERY_GOOGLE_DRIVE_FOLDERS_GQL,
    QUERY_GRAPH_GQL,
    QUERY_GUSTO_COMPANIES_GQL,
    QUERY_GUSTO_DEPARTMENTS_GQL,
    QUERY_GUSTO_LOCATIONS_GQL,
    QUERY_INVESTMENT_FUNDS_CLUSTERS_GQL,
    QUERY_INVESTMENT_FUNDS_EXPANDED_GQL,
    QUERY_INVESTMENT_FUNDS_GQL,
    QUERY_INVESTMENTS_CLUSTERS_GQL,
    QUERY_INVESTMENTS_EXPANDED_GQL,
    QUERY_INVESTMENTS_GQL,
    QUERY_JIRA_PROJECTS_GQL,
    QUERY_LABELS_GQL,
    QUERY_LINEAR_PROJECTS_GQL,
    QUERY_MEDICAL_CONDITIONS_CLUSTERS_GQL,
    QUERY_MEDICAL_CONDITIONS_GQL,
    QUERY_MEDICAL_CONTRAINDICATIONS_CLUSTERS_GQL,
    QUERY_MEDICAL_CONTRAINDICATIONS_GQL,
    QUERY_MEDICAL_DEVICES_CLUSTERS_GQL,
    QUERY_MEDICAL_DEVICES_GQL,
    QUERY_MEDICAL_DRUG_CLASSES_CLUSTERS_GQL,
    QUERY_MEDICAL_DRUG_CLASSES_GQL,
    QUERY_MEDICAL_DRUGS_CLUSTERS_GQL,
    QUERY_MEDICAL_DRUGS_GQL,
    QUERY_MEDICAL_GUIDELINES_CLUSTERS_GQL,
    QUERY_MEDICAL_GUIDELINES_GQL,
    QUERY_MEDICAL_INDICATIONS_CLUSTERS_GQL,
    QUERY_MEDICAL_INDICATIONS_GQL,
    QUERY_MEDICAL_PROCEDURES_CLUSTERS_GQL,
    QUERY_MEDICAL_PROCEDURES_GQL,
    QUERY_MEDICAL_STUDIES_CLUSTERS_GQL,
    QUERY_MEDICAL_STUDIES_GQL,
    QUERY_MEDICAL_TESTS_CLUSTERS_GQL,
    QUERY_MEDICAL_TESTS_GQL,
    QUERY_MEDICAL_THERAPIES_CLUSTERS_GQL,
    QUERY_MEDICAL_THERAPIES_GQL,
    QUERY_MICROSOFT_CALENDARS_GQL,
    QUERY_MICROSOFT_TEAMS_CHANNELS_GQL,
    QUERY_MICROSOFT_TEAMS_TEAMS_GQL,
    QUERY_MODELS_GQL,
    QUERY_MONDAY_BOARDS_GQL,
    QUERY_NOTION_DATABASES_GQL,
    QUERY_NOTION_PAGES_GQL,
    QUERY_OBSERVABLES_GQL,
    QUERY_ONE_DRIVE_FOLDERS_GQL,
    QUERY_ORGANIZATIONS_CLUSTERS_GQL,
    QUERY_ORGANIZATIONS_EXPANDED_GQL,
    QUERY_ORGANIZATIONS_GQL,
    QUERY_PERSONAS_GQL,
    QUERY_PERSONS_CLUSTERS_GQL,
    QUERY_PERSONS_EXPANDED_GQL,
    QUERY_PERSONS_GQL,
    QUERY_PLACES_CLUSTERS_GQL,
    QUERY_PLACES_GQL,
    QUERY_PRODUCTS_CLUSTERS_GQL,
    QUERY_PRODUCTS_GQL,
    QUERY_REPOS_CLUSTERS_GQL,
    QUERY_REPOS_GQL,
    QUERY_SHARE_POINT_FOLDERS_GQL,
    QUERY_SHARE_POINT_LIBRARIES_GQL,
    QUERY_SKILLS_GQL,
    QUERY_SLACK_CHANNELS_GQL,
    QUERY_SOFTWARES_CLUSTERS_GQL,
    QUERY_SOFTWARES_GQL,
    QUERY_SPECIFICATIONS_GQL,
    QUERY_TOKENS_GQL,
    QUERY_USAGE_GQL,
    QUERY_USERS_GQL,
    QUERY_VIEWS_GQL,
    QUERY_WORKFLOWS_GQL,
    REJECT_CONTENT_GQL,
    REMOVE_CONTENTS_FROM_COLLECTION_GQL,
    REMOVE_CONVERSATIONS_FROM_COLLECTION_GQL,
    RESEARCH_CONTENTS_GQL,
    RESOLVE_ENTITIES_GQL,
    RESOLVE_ENTITY_GQL,
    RESTART_CONTENT_GQL,
    RETRIEVE_ENTITIES_GQL,
    RETRIEVE_FACTS_GQL,
    RETRIEVE_SOURCES_GQL,
    RETRIEVE_VIEW_GQL,
    REVISE_CONTENT_GQL,
    REVISE_ENCODED_IMAGE_GQL,
    REVISE_IMAGE_GQL,
    REVISE_TEXT_GQL,
    SCREENSHOT_PAGE_GQL,
    SEARCH_WEB_GQL,
    SEND_NOTIFICATION_GQL,
    SPECIFICATION_EXISTS_GQL,
    SUGGEST_CONVERSATION_GQL,
    SUMMARIZE_CONTENTS_GQL,
    SUMMARIZE_TEXT_GQL,
    TRIGGER_FEED_GQL,
    UPDATE_AGENT_GQL,
    UPDATE_ALERT_GQL,
    UPDATE_CATEGORY_GQL,
    UPDATE_COLLECTION_GQL,
    UPDATE_CONNECTOR_GQL,
    UPDATE_CONTENT_GQL,
    UPDATE_CONVERSATION_GQL,
    UPDATE_EMOTION_GQL,
    UPDATE_EVENT_GQL,
    UPDATE_FACT_GQL,
    UPDATE_FEED_GQL,
    UPDATE_INVESTMENT_FUND_GQL,
    UPDATE_INVESTMENT_GQL,
    UPDATE_LABEL_GQL,
    UPDATE_MEDICAL_CONDITION_GQL,
    UPDATE_MEDICAL_CONTRAINDICATION_GQL,
    UPDATE_MEDICAL_DEVICE_GQL,
    UPDATE_MEDICAL_DRUG_CLASS_GQL,
    UPDATE_MEDICAL_DRUG_GQL,
    UPDATE_MEDICAL_GUIDELINE_GQL,
    UPDATE_MEDICAL_INDICATION_GQL,
    UPDATE_MEDICAL_PROCEDURE_GQL,
    UPDATE_MEDICAL_STUDY_GQL,
    UPDATE_MEDICAL_TEST_GQL,
    UPDATE_MEDICAL_THERAPY_GQL,
    UPDATE_OBSERVATION_GQL,
    UPDATE_ORGANIZATION_GQL,
    UPDATE_PERSON_GQL,
    UPDATE_PERSONA_GQL,
    UPDATE_PLACE_GQL,
    UPDATE_PRODUCT_GQL,
    UPDATE_PROJECT_GQL,
    UPDATE_REPO_GQL,
    UPDATE_SKILL_GQL,
    UPDATE_SOFTWARE_GQL,
    UPDATE_SPECIFICATION_GQL,
    UPDATE_USER_GQL,
    UPDATE_VIEW_GQL,
    UPDATE_WORKFLOW_GQL,
    UPSERT_AGENT_GQL,
    UPSERT_ALERT_GQL,
    UPSERT_CATEGORY_GQL,
    UPSERT_LABEL_GQL,
    UPSERT_SKILL_GQL,
    UPSERT_SPECIFICATION_GQL,
    UPSERT_VIEW_GQL,
    UPSERT_WORKFLOW_GQL,
    VIEW_EXISTS_GQL,
    WORKFLOW_EXISTS_GQL,
)
from .prompt import Prompt
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_agents import QueryAgents
from .query_alerts import QueryAlerts
from .query_asana_projects import QueryAsanaProjects
from .query_asana_workspaces import QueryAsanaWorkspaces
from .query_atlassian_sites import QueryAtlassianSites
from .query_bamboo_hr_departments import QueryBambooHRDepartments
from .query_bamboo_hr_divisions import QueryBambooHRDivisions
from .query_bamboo_hr_employment_statuses import QueryBambooHREmploymentStatuses
from .query_bamboo_hr_locations import QueryBambooHRLocations
from .query_box_folders import QueryBoxFolders
from .query_categories import QueryCategories
from .query_collections import QueryCollections
from .query_confluence_spaces import QueryConfluenceSpaces
from .query_connectors import QueryConnectors
from .query_contents import QueryContents
from .query_contents_facets import QueryContentsFacets
from .query_contents_graph import QueryContentsGraph
from .query_contents_observations import QueryContentsObservations
from .query_conversations import QueryConversations
from .query_conversations_clusters import QueryConversationsClusters
from .query_conversations_graph import QueryConversationsGraph
from .query_credits import QueryCredits
from .query_discord_channels import QueryDiscordChannels
from .query_discord_guilds import QueryDiscordGuilds
from .query_dropbox_folders import QueryDropboxFolders
from .query_emotions import QueryEmotions
from .query_events import QueryEvents
from .query_events_clusters import QueryEventsClusters
from .query_facts import QueryFacts
from .query_facts_clusters import QueryFactsClusters
from .query_facts_graph import QueryFactsGraph
from .query_feeds import QueryFeeds
from .query_git_hub_repositories import QueryGitHubRepositories
from .query_google_calendars import QueryGoogleCalendars
from .query_google_drive_drives import QueryGoogleDriveDrives
from .query_google_drive_folders import QueryGoogleDriveFolders
from .query_graph import QueryGraph
from .query_gusto_companies import QueryGustoCompanies
from .query_gusto_departments import QueryGustoDepartments
from .query_gusto_locations import QueryGustoLocations
from .query_investment_funds import QueryInvestmentFunds
from .query_investment_funds_clusters import QueryInvestmentFundsClusters
from .query_investment_funds_expanded import QueryInvestmentFundsExpanded
from .query_investments import QueryInvestments
from .query_investments_clusters import QueryInvestmentsClusters
from .query_investments_expanded import QueryInvestmentsExpanded
from .query_jira_projects import QueryJiraProjects
from .query_labels import QueryLabels
from .query_linear_projects import QueryLinearProjects
from .query_medical_conditions import QueryMedicalConditions
from .query_medical_conditions_clusters import QueryMedicalConditionsClusters
from .query_medical_contraindications import QueryMedicalContraindications
from .query_medical_contraindications_clusters import (
    QueryMedicalContraindicationsClusters,
)
from .query_medical_devices import QueryMedicalDevices
from .query_medical_devices_clusters import QueryMedicalDevicesClusters
from .query_medical_drug_classes import QueryMedicalDrugClasses
from .query_medical_drug_classes_clusters import QueryMedicalDrugClassesClusters
from .query_medical_drugs import QueryMedicalDrugs
from .query_medical_drugs_clusters import QueryMedicalDrugsClusters
from .query_medical_guidelines import QueryMedicalGuidelines
from .query_medical_guidelines_clusters import QueryMedicalGuidelinesClusters
from .query_medical_indications import QueryMedicalIndications
from .query_medical_indications_clusters import QueryMedicalIndicationsClusters
from .query_medical_procedures import QueryMedicalProcedures
from .query_medical_procedures_clusters import QueryMedicalProceduresClusters
from .query_medical_studies import QueryMedicalStudies
from .query_medical_studies_clusters import QueryMedicalStudiesClusters
from .query_medical_tests import QueryMedicalTests
from .query_medical_tests_clusters import QueryMedicalTestsClusters
from .query_medical_therapies import QueryMedicalTherapies
from .query_medical_therapies_clusters import QueryMedicalTherapiesClusters
from .query_microsoft_calendars import QueryMicrosoftCalendars
from .query_microsoft_teams_channels import QueryMicrosoftTeamsChannels
from .query_microsoft_teams_teams import QueryMicrosoftTeamsTeams
from .query_models import QueryModels
from .query_monday_boards import QueryMondayBoards
from .query_notion_databases import QueryNotionDatabases
from .query_notion_pages import QueryNotionPages
from .query_observables import QueryObservables
from .query_one_drive_folders import QueryOneDriveFolders
from .query_organizations import QueryOrganizations
from .query_organizations_clusters import QueryOrganizationsClusters
from .query_organizations_expanded import QueryOrganizationsExpanded
from .query_personas import QueryPersonas
from .query_persons import QueryPersons
from .query_persons_clusters import QueryPersonsClusters
from .query_persons_expanded import QueryPersonsExpanded
from .query_places import QueryPlaces
from .query_places_clusters import QueryPlacesClusters
from .query_products import QueryProducts
from .query_products_clusters import QueryProductsClusters
from .query_repos import QueryRepos
from .query_repos_clusters import QueryReposClusters
from .query_share_point_folders import QuerySharePointFolders
from .query_share_point_libraries import QuerySharePointLibraries
from .query_skills import QuerySkills
from .query_slack_channels import QuerySlackChannels
from .query_softwares import QuerySoftwares
from .query_softwares_clusters import QuerySoftwaresClusters
from .query_specifications import QuerySpecifications
from .query_tokens import QueryTokens
from .query_usage import QueryUsage
from .query_users import QueryUsers
from .query_views import QueryViews
from .query_workflows import QueryWorkflows
from .reject_content import RejectContent
from .remove_contents_from_collection import RemoveContentsFromCollection
from .remove_conversations_from_collection import RemoveConversationsFromCollection
from .research_contents import ResearchContents
from .resolve_entities import ResolveEntities
from .resolve_entity import ResolveEntity
from .restart_content import RestartContent
from .retrieve_entities import RetrieveEntities
from .retrieve_facts import RetrieveFacts
from .retrieve_sources import RetrieveSources
from .retrieve_view import RetrieveView
from .revise_content import ReviseContent
from .revise_encoded_image import ReviseEncodedImage
from .revise_image import ReviseImage
from .revise_text import ReviseText
from .screenshot_page import ScreenshotPage
from .search_web import SearchWeb
from .send_notification import SendNotification
from .specification_exists import SpecificationExists
from .suggest_conversation import SuggestConversation
from .summarize_contents import SummarizeContents
from .summarize_text import SummarizeText
from .trigger_feed import TriggerFeed
from .update_agent import UpdateAgent
from .update_alert import UpdateAlert
from .update_category import UpdateCategory
from .update_collection import UpdateCollection
from .update_connector import UpdateConnector
from .update_content import UpdateContent
from .update_conversation import UpdateConversation
from .update_emotion import UpdateEmotion
from .update_event import UpdateEvent
from .update_fact import UpdateFact
from .update_feed import UpdateFeed
from .update_investment import UpdateInvestment
from .update_investment_fund import UpdateInvestmentFund
from .update_label import UpdateLabel
from .update_medical_condition import UpdateMedicalCondition
from .update_medical_contraindication import UpdateMedicalContraindication
from .update_medical_device import UpdateMedicalDevice
from .update_medical_drug import UpdateMedicalDrug
from .update_medical_drug_class import UpdateMedicalDrugClass
from .update_medical_guideline import UpdateMedicalGuideline
from .update_medical_indication import UpdateMedicalIndication
from .update_medical_procedure import UpdateMedicalProcedure
from .update_medical_study import UpdateMedicalStudy
from .update_medical_test import UpdateMedicalTest
from .update_medical_therapy import UpdateMedicalTherapy
from .update_observation import UpdateObservation
from .update_organization import UpdateOrganization
from .update_person import UpdatePerson
from .update_persona import UpdatePersona
from .update_place import UpdatePlace
from .update_product import UpdateProduct
from .update_project import UpdateProject
from .update_repo import UpdateRepo
from .update_skill import UpdateSkill
from .update_software import UpdateSoftware
from .update_specification import UpdateSpecification
from .update_user import UpdateUser
from .update_view import UpdateView
from .update_workflow import UpdateWorkflow
from .upsert_agent import UpsertAgent
from .upsert_alert import UpsertAlert
from .upsert_category import UpsertCategory
from .upsert_label import UpsertLabel
from .upsert_skill import UpsertSkill
from .upsert_specification import UpsertSpecification
from .upsert_view import UpsertView
from .upsert_workflow import UpsertWorkflow
from .view_exists import ViewExists
from .workflow_exists import WorkflowExists


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


class Client(AsyncBaseClient):
    async def count_agents(
        self,
        filter: Union[Optional[AgentFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountAgents:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_AGENTS_GQL,
            operation_name="CountAgents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountAgents.model_validate(data)

    async def create_agent(
        self,
        agent: AgentInput,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CreateAgent:
        variables: dict[str, object] = {"agent": agent, "correlationId": correlation_id}
        response = await self.execute(
            query=CREATE_AGENT_GQL,
            operation_name="CreateAgent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateAgent.model_validate(data)

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

    async def delete_agents(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteAgents:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_AGENTS_GQL,
            operation_name="DeleteAgents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteAgents.model_validate(data)

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

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

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

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

    async def query_agents(
        self,
        filter: Union[Optional[AgentFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryAgents:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_AGENTS_GQL,
            operation_name="QueryAgents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryAgents.model_validate(data)

    async def update_agent(self, agent: AgentUpdateInput, **kwargs: Any) -> UpdateAgent:
        variables: dict[str, object] = {"agent": agent}
        response = await self.execute(
            query=UPDATE_AGENT_GQL,
            operation_name="UpdateAgent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateAgent.model_validate(data)

    async def upsert_agent(self, agent: AgentInput, **kwargs: Any) -> UpsertAgent:
        variables: dict[str, object] = {"agent": agent}
        response = await self.execute(
            query=UPSERT_AGENT_GQL,
            operation_name="UpsertAgent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpsertAgent.model_validate(data)

    async def count_alerts(
        self,
        filter: Union[Optional[AlertFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountAlerts:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetAlert:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryAlerts:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 upsert_alert(self, alert: AlertInput, **kwargs: Any) -> UpsertAlert:
        variables: dict[str, object] = {"alert": alert}
        response = await self.execute(
            query=UPSERT_ALERT_GQL,
            operation_name="UpsertAlert",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpsertAlert.model_validate(data)

    async def count_categories(
        self,
        filter: Union[Optional[CategoryFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountCategories:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetCategory:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryCategories:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 upsert_category(
        self, category: CategoryInput, **kwargs: Any
    ) -> UpsertCategory:
        variables: dict[str, object] = {"category": category}
        response = await self.execute(
            query=UPSERT_CATEGORY_GQL,
            operation_name="UpsertCategory",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpsertCategory.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 add_conversations_to_collections(
        self,
        conversations: list[EntityReferenceInput],
        collections: list[EntityReferenceInput],
        **kwargs: Any
    ) -> AddConversationsToCollections:
        variables: dict[str, object] = {
            "conversations": conversations,
            "collections": collections,
        }
        response = await self.execute(
            query=ADD_CONVERSATIONS_TO_COLLECTIONS_GQL,
            operation_name="AddConversationsToCollections",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return AddConversationsToCollections.model_validate(data)

    async def count_collections(
        self,
        filter: Union[Optional[CollectionFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountCollections:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetCollection:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryCollections:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 remove_conversations_from_collection(
        self,
        conversations: list[EntityReferenceInput],
        collection: EntityReferenceInput,
        **kwargs: Any
    ) -> RemoveConversationsFromCollection:
        variables: dict[str, object] = {
            "conversations": conversations,
            "collection": collection,
        }
        response = await self.execute(
            query=REMOVE_CONVERSATIONS_FROM_COLLECTION_GQL,
            operation_name="RemoveConversationsFromCollection",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return RemoveConversationsFromCollection.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_connectors(
        self,
        filter: Union[Optional[ConnectorFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountConnectors:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_CONNECTORS_GQL,
            operation_name="CountConnectors",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountConnectors.model_validate(data)

    async def create_connector(
        self, connector: ConnectorInput, **kwargs: Any
    ) -> CreateConnector:
        variables: dict[str, object] = {"connector": connector}
        response = await self.execute(
            query=CREATE_CONNECTOR_GQL,
            operation_name="CreateConnector",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateConnector.model_validate(data)

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

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

    async def query_connectors(
        self,
        filter: Union[Optional[ConnectorFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryConnectors:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_CONNECTORS_GQL,
            operation_name="QueryConnectors",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryConnectors.model_validate(data)

    async def update_connector(
        self, connector: ConnectorUpdateInput, **kwargs: Any
    ) -> UpdateConnector:
        variables: dict[str, object] = {"connector": connector}
        response = await self.execute(
            query=UPDATE_CONNECTOR_GQL,
            operation_name="UpdateConnector",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateConnector.model_validate(data)

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

    async def count_contents(
        self,
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountContents:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 describe_encoded_image(
        self,
        prompt: str,
        mime_type: str,
        data: str,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DescribeEncodedImage:
        variables: dict[str, object] = {
            "prompt": prompt,
            "mimeType": mime_type,
            "data": data,
            "specification": specification,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DESCRIBE_ENCODED_IMAGE_GQL,
            operation_name="DescribeEncodedImage",
            variables=variables,
            **kwargs
        )
        _data = self.get_data(response)
        return DescribeEncodedImage.model_validate(_data)

    async def describe_image(
        self,
        prompt: str,
        uri: Any,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DescribeImage:
        variables: dict[str, object] = {
            "prompt": prompt,
            "uri": uri,
            "specification": specification,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DESCRIBE_IMAGE_GQL,
            operation_name="DescribeImage",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DescribeImage.model_validate(data)

    async def distribute(
        self,
        connector: DistributionConnectorInput,
        authentication: EntityReferenceInput,
        text: Union[Optional[str], UnsetType] = UNSET,
        text_type: Union[Optional[TextTypes], UnsetType] = UNSET,
        name: Union[Optional[str], UnsetType] = UNSET,
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> Distribute:
        variables: dict[str, object] = {
            "connector": connector,
            "authentication": authentication,
            "text": text,
            "textType": text_type,
            "name": name,
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=DISTRIBUTE_GQL,
            operation_name="Distribute",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return Distribute.model_validate(data)

    async def extract_contents(
        self,
        prompt: str,
        tools: list[ToolDefinitionInput],
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ExtractContents:
        variables: dict[str, object] = {
            "prompt": prompt,
            "filter": filter,
            "specification": specification,
            "tools": tools,
            "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 extract_observables(
        self,
        text: str,
        text_type: Union[Optional[TextTypes], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        observable_types: Union[Optional[list[ObservableTypes]], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ExtractObservables:
        variables: dict[str, object] = {
            "text": text,
            "textType": text_type,
            "specification": specification,
            "observableTypes": observable_types,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=EXTRACT_OBSERVABLES_GQL,
            operation_name="ExtractObservables",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ExtractObservables.model_validate(data)

    async def extract_text(
        self,
        prompt: str,
        text: str,
        tools: list[ToolDefinitionInput],
        text_type: Union[Optional[TextTypes], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ExtractText:
        variables: dict[str, object] = {
            "prompt": prompt,
            "text": text,
            "textType": text_type,
            "specification": specification,
            "tools": tools,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=EXTRACT_TEXT_GQL,
            operation_name="ExtractText",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ExtractText.model_validate(data)

    async def get_content(
        self,
        id: str,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetContent:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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_batch(
        self,
        uris: list[Any],
        workflow: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        collections: Union[Optional[list[EntityReferenceInput]], UnsetType] = UNSET,
        observations: Union[
            Optional[list[ObservationReferenceInput]], UnsetType
        ] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> IngestBatch:
        variables: dict[str, object] = {
            "uris": uris,
            "workflow": workflow,
            "collections": collections,
            "observations": observations,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=INGEST_BATCH_GQL,
            operation_name="IngestBatch",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return IngestBatch.model_validate(data)

    async def ingest_encoded_file(
        self,
        name: str,
        data: str,
        mime_type: str,
        id: Union[Optional[str], UnsetType] = UNSET,
        identifier: Union[Optional[str], UnsetType] = UNSET,
        file_creation_date: Union[Optional[Any], UnsetType] = UNSET,
        file_modified_date: Union[Optional[Any], UnsetType] = UNSET,
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        collections: Union[Optional[list[EntityReferenceInput]], UnsetType] = UNSET,
        observations: Union[
            Optional[list[ObservationReferenceInput]], 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,
            "identifier": identifier,
            "fileCreationDate": file_creation_date,
            "fileModifiedDate": file_modified_date,
            "isSynchronous": is_synchronous,
            "collections": collections,
            "observations": observations,
            "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_event(
        self,
        markdown: str,
        name: Union[Optional[str], UnsetType] = UNSET,
        description: Union[Optional[str], UnsetType] = UNSET,
        event_date: Union[Optional[Any], UnsetType] = UNSET,
        id: Union[Optional[str], UnsetType] = UNSET,
        identifier: Union[Optional[str], UnsetType] = UNSET,
        collections: Union[Optional[list[EntityReferenceInput]], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> IngestEvent:
        variables: dict[str, object] = {
            "markdown": markdown,
            "name": name,
            "description": description,
            "eventDate": event_date,
            "id": id,
            "identifier": identifier,
            "collections": collections,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=INGEST_EVENT_GQL,
            operation_name="IngestEvent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return IngestEvent.model_validate(data)

    async def ingest_memory(
        self,
        text: str,
        name: Union[Optional[str], UnsetType] = UNSET,
        text_type: Union[Optional[TextTypes], UnsetType] = UNSET,
        id: Union[Optional[str], UnsetType] = UNSET,
        identifier: Union[Optional[str], UnsetType] = UNSET,
        collections: Union[Optional[list[EntityReferenceInput]], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> IngestMemory:
        variables: dict[str, object] = {
            "text": text,
            "name": name,
            "textType": text_type,
            "id": id,
            "identifier": identifier,
            "collections": collections,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=INGEST_MEMORY_GQL,
            operation_name="IngestMemory",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return IngestMemory.model_validate(data)

    async def ingest_text(
        self,
        text: str,
        name: Union[Optional[str], UnsetType] = UNSET,
        text_type: Union[Optional[TextTypes], UnsetType] = UNSET,
        uri: Union[Optional[Any], UnsetType] = UNSET,
        id: Union[Optional[str], UnsetType] = UNSET,
        identifier: 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,
        observations: Union[
            Optional[list[ObservationReferenceInput]], UnsetType
        ] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> IngestText:
        variables: dict[str, object] = {
            "text": text,
            "name": name,
            "textType": text_type,
            "uri": uri,
            "id": id,
            "identifier": identifier,
            "isSynchronous": is_synchronous,
            "workflow": workflow,
            "collections": collections,
            "observations": observations,
            "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_text_batch(
        self,
        batch: list[TextContentInput],
        text_type: Union[Optional[TextTypes], UnsetType] = UNSET,
        workflow: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        collections: Union[Optional[list[EntityReferenceInput]], UnsetType] = UNSET,
        observations: Union[
            Optional[list[ObservationReferenceInput]], UnsetType
        ] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> IngestTextBatch:
        variables: dict[str, object] = {
            "batch": batch,
            "textType": text_type,
            "workflow": workflow,
            "collections": collections,
            "observations": observations,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=INGEST_TEXT_BATCH_GQL,
            operation_name="IngestTextBatch",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return IngestTextBatch.model_validate(data)

    async def ingest_uri(
        self,
        uri: Any,
        name: Union[Optional[str], UnsetType] = UNSET,
        id: Union[Optional[str], UnsetType] = UNSET,
        mime_type: Union[Optional[str], UnsetType] = UNSET,
        identifier: 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,
        observations: Union[
            Optional[list[ObservationReferenceInput]], UnsetType
        ] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> IngestUri:
        variables: dict[str, object] = {
            "name": name,
            "uri": uri,
            "id": id,
            "mimeType": mime_type,
            "identifier": identifier,
            "isSynchronous": is_synchronous,
            "workflow": workflow,
            "collections": collections,
            "observations": observations,
            "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 lookup_contents(
        self,
        ids: list[str],
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> LookupContents:
        variables: dict[str, object] = {"ids": ids, "correlationId": correlation_id}
        response = await self.execute(
            query=LOOKUP_CONTENTS_GQL,
            operation_name="LookupContents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return LookupContents.model_validate(data)

    async def lookup_entity(
        self,
        filter: EntityRelationshipsFilter,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> LookupEntity:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=LOOKUP_ENTITY_GQL,
            operation_name="LookupEntity",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return LookupEntity.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,
        include_details: Union[Optional[bool], 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,
            "includeDetails": include_details,
            "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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryContents:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryContentsFacets:
        variables: dict[str, object] = {
            "filter": filter,
            "facets": facets,
            "correlationId": correlation_id,
        }
        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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryContentsGraph:
        variables: dict[str, object] = {
            "filter": filter,
            "graph": graph,
            "correlationId": correlation_id,
        }
        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 query_contents_observations(
        self,
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryContentsObservations:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_CONTENTS_OBSERVATIONS_GQL,
            operation_name="QueryContentsObservations",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryContentsObservations.model_validate(data)

    async def query_graph(
        self,
        filter: Union[Optional[GraphFilter], UnsetType] = UNSET,
        graph: Union[Optional[GraphInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryGraph:
        variables: dict[str, object] = {
            "filter": filter,
            "graph": graph,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_GRAPH_GQL,
            operation_name="QueryGraph",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryGraph.model_validate(data)

    async def query_observables(
        self,
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryObservables:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_OBSERVABLES_GQL,
            operation_name="QueryObservables",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryObservables.model_validate(data)

    async def reject_content(
        self, id: str, reason: Union[Optional[str], UnsetType] = UNSET, **kwargs: Any
    ) -> RejectContent:
        variables: dict[str, object] = {"id": id, "reason": reason}
        response = await self.execute(
            query=REJECT_CONTENT_GQL,
            operation_name="RejectContent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return RejectContent.model_validate(data)

    async def research_contents(
        self,
        connector: ContentPublishingConnectorInput,
        filter: Union[Optional[ContentFilter], 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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ResearchContents:
        variables: dict[str, object] = {
            "connector": connector,
            "filter": filter,
            "name": name,
            "summarySpecification": summary_specification,
            "publishSpecification": publish_specification,
            "workflow": workflow,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=RESEARCH_CONTENTS_GQL,
            operation_name="ResearchContents",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ResearchContents.model_validate(data)

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

    async def screenshot_page(
        self,
        uri: Any,
        maximum_height: Union[Optional[int], 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
    ) -> ScreenshotPage:
        variables: dict[str, object] = {
            "uri": uri,
            "maximumHeight": maximum_height,
            "isSynchronous": is_synchronous,
            "workflow": workflow,
            "collections": collections,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=SCREENSHOT_PAGE_GQL,
            operation_name="ScreenshotPage",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ScreenshotPage.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 summarize_text(
        self,
        summarization: SummarizationStrategyInput,
        text: str,
        text_type: Union[Optional[TextTypes], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> SummarizeText:
        variables: dict[str, object] = {
            "summarization": summarization,
            "text": text,
            "textType": text_type,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=SUMMARIZE_TEXT_GQL,
            operation_name="SummarizeText",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return SummarizeText.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 ask_graphlit(
        self,
        prompt: str,
        type: Union[Optional[SdkTypes], UnsetType] = UNSET,
        id: Union[Optional[str], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> AskGraphlit:
        variables: dict[str, object] = {
            "prompt": prompt,
            "type": type,
            "id": id,
            "specification": specification,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=ASK_GRAPHLIT_GQL,
            operation_name="AskGraphlit",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return AskGraphlit.model_validate(data)

    async def branch_conversation(self, id: str, **kwargs: Any) -> BranchConversation:
        variables: dict[str, object] = {"id": id}
        response = await self.execute(
            query=BRANCH_CONVERSATION_GQL,
            operation_name="BranchConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return BranchConversation.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 complete_conversation(
        self,
        completion: str,
        id: str,
        completion_time: Union[Optional[Any], UnsetType] = UNSET,
        ttft: Union[Optional[Any], UnsetType] = UNSET,
        throughput: Union[Optional[float], UnsetType] = UNSET,
        artifacts: Union[Optional[list[EntityReferenceInput]], UnsetType] = UNSET,
        messages: Union[Optional[list[ConversationMessageInput]], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CompleteConversation:
        variables: dict[str, object] = {
            "completion": completion,
            "id": id,
            "completionTime": completion_time,
            "ttft": ttft,
            "throughput": throughput,
            "artifacts": artifacts,
            "messages": messages,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COMPLETE_CONVERSATION_GQL,
            operation_name="CompleteConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CompleteConversation.model_validate(data)

    async def continue_conversation(
        self,
        id: str,
        responses: list[ConversationToolResponseInput],
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ContinueConversation:
        variables: dict[str, object] = {
            "id": id,
            "responses": responses,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=CONTINUE_CONVERSATION_GQL,
            operation_name="ContinueConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ContinueConversation.model_validate(data)

    async def count_conversations(
        self,
        filter: Union[Optional[ConversationFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountConversations:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 format_conversation(
        self,
        prompt: str,
        id: Union[Optional[str], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        persona: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        tools: Union[Optional[list[ToolDefinitionInput]], UnsetType] = UNSET,
        system_prompt: Union[Optional[str], UnsetType] = UNSET,
        include_details: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        instructions: Union[Optional[str], UnsetType] = UNSET,
        scratchpad: Union[Optional[str], UnsetType] = UNSET,
        skills: Union[Optional[list[EntityReferenceInput]], UnsetType] = UNSET,
        **kwargs: Any
    ) -> FormatConversation:
        variables: dict[str, object] = {
            "prompt": prompt,
            "id": id,
            "specification": specification,
            "persona": persona,
            "tools": tools,
            "systemPrompt": system_prompt,
            "includeDetails": include_details,
            "correlationId": correlation_id,
            "instructions": instructions,
            "scratchpad": scratchpad,
            "skills": skills,
        }
        response = await self.execute(
            query=FORMAT_CONVERSATION_GQL,
            operation_name="FormatConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return FormatConversation.model_validate(data)

    async def get_conversation(
        self,
        id: str,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetConversation:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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(
        self,
        prompt: Union[Optional[str], UnsetType] = UNSET,
        mime_type: Union[Optional[str], UnsetType] = UNSET,
        data: Union[Optional[str], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        messages: Union[Optional[list[ConversationMessageInput]], UnsetType] = UNSET,
        tools: Union[Optional[list[ToolDefinitionInput]], UnsetType] = UNSET,
        require_tool: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> Prompt:
        variables: dict[str, object] = {
            "prompt": prompt,
            "mimeType": mime_type,
            "data": data,
            "specification": specification,
            "messages": messages,
            "tools": tools,
            "requireTool": require_tool,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=PROMPT_GQL, operation_name="Prompt", variables=variables, **kwargs
        )
        _data = self.get_data(response)
        return Prompt.model_validate(_data)

    async def prompt_conversation(
        self,
        prompt: str,
        mime_type: Union[Optional[str], UnsetType] = UNSET,
        data: Union[Optional[str], UnsetType] = UNSET,
        id: Union[Optional[str], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        persona: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        system_prompt: Union[Optional[str], UnsetType] = UNSET,
        tools: Union[Optional[list[ToolDefinitionInput]], UnsetType] = UNSET,
        require_tool: Union[Optional[bool], UnsetType] = UNSET,
        include_details: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        instructions: Union[Optional[str], UnsetType] = UNSET,
        scratchpad: Union[Optional[str], UnsetType] = UNSET,
        skills: Union[Optional[list[EntityReferenceInput]], UnsetType] = UNSET,
        **kwargs: Any
    ) -> PromptConversation:
        variables: dict[str, object] = {
            "prompt": prompt,
            "mimeType": mime_type,
            "data": data,
            "id": id,
            "specification": specification,
            "persona": persona,
            "systemPrompt": system_prompt,
            "tools": tools,
            "requireTool": require_tool,
            "includeDetails": include_details,
            "correlationId": correlation_id,
            "instructions": instructions,
            "scratchpad": scratchpad,
            "skills": skills,
        }
        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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryConversations:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 query_conversations_clusters(
        self,
        filter: Union[Optional[ConversationFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryConversationsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_CONVERSATIONS_CLUSTERS_GQL,
            operation_name="QueryConversationsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryConversationsClusters.model_validate(data)

    async def query_conversations_graph(
        self,
        filter: Union[Optional[ConversationFilter], UnsetType] = UNSET,
        graph: Union[Optional[ConversationGraphInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryConversationsGraph:
        variables: dict[str, object] = {
            "filter": filter,
            "graph": graph,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_CONVERSATIONS_GRAPH_GQL,
            operation_name="QueryConversationsGraph",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryConversationsGraph.model_validate(data)

    async def retrieve_entities(
        self,
        prompt: str,
        types: Union[Optional[list[ObservableTypes]], UnsetType] = UNSET,
        search_type: Union[Optional[SearchTypes], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> RetrieveEntities:
        variables: dict[str, object] = {
            "prompt": prompt,
            "types": types,
            "searchType": search_type,
            "limit": limit,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=RETRIEVE_ENTITIES_GQL,
            operation_name="RetrieveEntities",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return RetrieveEntities.model_validate(data)

    async def retrieve_facts(
        self,
        prompt: str,
        filter: Union[Optional[FactFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> RetrieveFacts:
        variables: dict[str, object] = {
            "prompt": prompt,
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=RETRIEVE_FACTS_GQL,
            operation_name="RetrieveFacts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return RetrieveFacts.model_validate(data)

    async def retrieve_sources(
        self,
        prompt: str,
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        augmented_filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        retrieval_strategy: Union[Optional[RetrievalStrategyInput], UnsetType] = UNSET,
        reranking_strategy: Union[Optional[RerankingStrategyInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> RetrieveSources:
        variables: dict[str, object] = {
            "prompt": prompt,
            "filter": filter,
            "augmentedFilter": augmented_filter,
            "retrievalStrategy": retrieval_strategy,
            "rerankingStrategy": reranking_strategy,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=RETRIEVE_SOURCES_GQL,
            operation_name="RetrieveSources",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return RetrieveSources.model_validate(data)

    async def retrieve_view(
        self,
        prompt: str,
        id: str,
        retrieval_strategy: Union[Optional[RetrievalStrategyInput], UnsetType] = UNSET,
        reranking_strategy: Union[Optional[RerankingStrategyInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> RetrieveView:
        variables: dict[str, object] = {
            "prompt": prompt,
            "id": id,
            "retrievalStrategy": retrieval_strategy,
            "rerankingStrategy": reranking_strategy,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=RETRIEVE_VIEW_GQL,
            operation_name="RetrieveView",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return RetrieveView.model_validate(data)

    async def revise_content(
        self,
        prompt: str,
        content: EntityReferenceInput,
        id: Union[Optional[str], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ReviseContent:
        variables: dict[str, object] = {
            "prompt": prompt,
            "content": content,
            "id": id,
            "specification": specification,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=REVISE_CONTENT_GQL,
            operation_name="ReviseContent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ReviseContent.model_validate(data)

    async def revise_encoded_image(
        self,
        prompt: str,
        mime_type: str,
        data: str,
        id: Union[Optional[str], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ReviseEncodedImage:
        variables: dict[str, object] = {
            "prompt": prompt,
            "mimeType": mime_type,
            "data": data,
            "id": id,
            "specification": specification,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=REVISE_ENCODED_IMAGE_GQL,
            operation_name="ReviseEncodedImage",
            variables=variables,
            **kwargs
        )
        _data = self.get_data(response)
        return ReviseEncodedImage.model_validate(_data)

    async def revise_image(
        self,
        prompt: str,
        uri: Any,
        id: Union[Optional[str], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ReviseImage:
        variables: dict[str, object] = {
            "prompt": prompt,
            "uri": uri,
            "id": id,
            "specification": specification,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=REVISE_IMAGE_GQL,
            operation_name="ReviseImage",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ReviseImage.model_validate(data)

    async def revise_text(
        self,
        prompt: str,
        text: str,
        id: Union[Optional[str], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ReviseText:
        variables: dict[str, object] = {
            "prompt": prompt,
            "text": text,
            "id": id,
            "specification": specification,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=REVISE_TEXT_GQL,
            operation_name="ReviseText",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ReviseText.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_emotions(
        self,
        filter: Union[Optional[EmotionFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountEmotions:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_EMOTIONS_GQL,
            operation_name="CountEmotions",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountEmotions.model_validate(data)

    async def create_emotion(
        self, emotion: EmotionInput, **kwargs: Any
    ) -> CreateEmotion:
        variables: dict[str, object] = {"emotion": emotion}
        response = await self.execute(
            query=CREATE_EMOTION_GQL,
            operation_name="CreateEmotion",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateEmotion.model_validate(data)

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

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

    async def delete_emotions(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteEmotions:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_EMOTIONS_GQL,
            operation_name="DeleteEmotions",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteEmotions.model_validate(data)

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

    async def query_emotions(
        self,
        filter: Union[Optional[EmotionFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryEmotions:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_EMOTIONS_GQL,
            operation_name="QueryEmotions",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryEmotions.model_validate(data)

    async def update_emotion(
        self, emotion: EmotionUpdateInput, **kwargs: Any
    ) -> UpdateEmotion:
        variables: dict[str, object] = {"emotion": emotion}
        response = await self.execute(
            query=UPDATE_EMOTION_GQL,
            operation_name="UpdateEmotion",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateEmotion.model_validate(data)

    async def count_events(
        self,
        filter: Union[Optional[EventFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountEvents:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetEvent:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryEvents:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 query_events_clusters(
        self,
        filter: Union[Optional[EventFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryEventsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_EVENTS_CLUSTERS_GQL,
            operation_name="QueryEventsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryEventsClusters.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_facts(
        self,
        filter: Union[Optional[FactFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountFacts:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_FACTS_GQL,
            operation_name="CountFacts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountFacts.model_validate(data)

    async def create_fact(self, fact: FactInput, **kwargs: Any) -> CreateFact:
        variables: dict[str, object] = {"fact": fact}
        response = await self.execute(
            query=CREATE_FACT_GQL,
            operation_name="CreateFact",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateFact.model_validate(data)

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

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

    async def delete_facts(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteFacts:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_FACTS_GQL,
            operation_name="DeleteFacts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteFacts.model_validate(data)

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

    async def query_facts(
        self,
        filter: Union[Optional[FactFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryFacts:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_FACTS_GQL,
            operation_name="QueryFacts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryFacts.model_validate(data)

    async def query_facts_clusters(
        self,
        filter: Union[Optional[FactFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryFactsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_FACTS_CLUSTERS_GQL,
            operation_name="QueryFactsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryFactsClusters.model_validate(data)

    async def query_facts_graph(
        self,
        filter: Union[Optional[FactFilter], UnsetType] = UNSET,
        graph: Union[Optional[FactGraphInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryFactsGraph:
        variables: dict[str, object] = {
            "filter": filter,
            "graph": graph,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_FACTS_GRAPH_GQL,
            operation_name="QueryFactsGraph",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryFactsGraph.model_validate(data)

    async def update_fact(self, fact: FactUpdateInput, **kwargs: Any) -> UpdateFact:
        variables: dict[str, object] = {"fact": fact}
        response = await self.execute(
            query=UPDATE_FACT_GQL,
            operation_name="UpdateFact",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateFact.model_validate(data)

    async def count_feeds(
        self,
        filter: Union[Optional[FeedFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountFeeds:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 feed_exists(
        self,
        filter: Union[Optional[FeedFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> FeedExists:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=FEED_EXISTS_GQL,
            operation_name="FeedExists",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return FeedExists.model_validate(data)

    async def get_feed(
        self,
        id: str,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetFeed:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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 lookup_companies(
        self,
        name: Union[Optional[str], UnsetType] = UNSET,
        domain: Union[Optional[str], UnsetType] = UNSET,
        linked_in_url: Union[Optional[Any], UnsetType] = UNSET,
        **kwargs: Any
    ) -> LookupCompanies:
        variables: dict[str, object] = {
            "name": name,
            "domain": domain,
            "linkedInUrl": linked_in_url,
        }
        response = await self.execute(
            query=LOOKUP_COMPANIES_GQL,
            operation_name="LookupCompanies",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return LookupCompanies.model_validate(data)

    async def lookup_persons(
        self,
        linked_in_url: Union[Optional[Any], UnsetType] = UNSET,
        email: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> LookupPersons:
        variables: dict[str, object] = {"linkedInUrl": linked_in_url, "email": email}
        response = await self.execute(
            query=LOOKUP_PERSONS_GQL,
            operation_name="LookupPersons",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return LookupPersons.model_validate(data)

    async def query_asana_projects(
        self, properties: AsanaProjectsInput, **kwargs: Any
    ) -> QueryAsanaProjects:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_ASANA_PROJECTS_GQL,
            operation_name="QueryAsanaProjects",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryAsanaProjects.model_validate(data)

    async def query_asana_workspaces(
        self, properties: AsanaWorkspacesInput, **kwargs: Any
    ) -> QueryAsanaWorkspaces:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_ASANA_WORKSPACES_GQL,
            operation_name="QueryAsanaWorkspaces",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryAsanaWorkspaces.model_validate(data)

    async def query_atlassian_sites(
        self, properties: AtlassianSitesInput, **kwargs: Any
    ) -> QueryAtlassianSites:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_ATLASSIAN_SITES_GQL,
            operation_name="QueryAtlassianSites",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryAtlassianSites.model_validate(data)

    async def query_bamboo_hr_departments(
        self, properties: BambooHROptionsInput, **kwargs: Any
    ) -> QueryBambooHRDepartments:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_BAMBOO_HR_DEPARTMENTS_GQL,
            operation_name="QueryBambooHRDepartments",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryBambooHRDepartments.model_validate(data)

    async def query_bamboo_hr_divisions(
        self, properties: BambooHROptionsInput, **kwargs: Any
    ) -> QueryBambooHRDivisions:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_BAMBOO_HR_DIVISIONS_GQL,
            operation_name="QueryBambooHRDivisions",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryBambooHRDivisions.model_validate(data)

    async def query_bamboo_hr_employment_statuses(
        self, properties: BambooHROptionsInput, **kwargs: Any
    ) -> QueryBambooHREmploymentStatuses:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_BAMBOO_HR_EMPLOYMENT_STATUSES_GQL,
            operation_name="QueryBambooHREmploymentStatuses",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryBambooHREmploymentStatuses.model_validate(data)

    async def query_bamboo_hr_locations(
        self, properties: BambooHROptionsInput, **kwargs: Any
    ) -> QueryBambooHRLocations:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_BAMBOO_HR_LOCATIONS_GQL,
            operation_name="QueryBambooHRLocations",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryBambooHRLocations.model_validate(data)

    async def query_box_folders(
        self,
        properties: BoxFoldersInput,
        folder_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryBoxFolders:
        variables: dict[str, object] = {"properties": properties, "folderId": folder_id}
        response = await self.execute(
            query=QUERY_BOX_FOLDERS_GQL,
            operation_name="QueryBoxFolders",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryBoxFolders.model_validate(data)

    async def query_confluence_spaces(
        self, properties: ConfluenceSpacesInput, **kwargs: Any
    ) -> QueryConfluenceSpaces:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_CONFLUENCE_SPACES_GQL,
            operation_name="QueryConfluenceSpaces",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryConfluenceSpaces.model_validate(data)

    async def query_discord_channels(
        self, properties: DiscordChannelsInput, **kwargs: Any
    ) -> QueryDiscordChannels:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_DISCORD_CHANNELS_GQL,
            operation_name="QueryDiscordChannels",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryDiscordChannels.model_validate(data)

    async def query_discord_guilds(
        self, properties: DiscordGuildsInput, **kwargs: Any
    ) -> QueryDiscordGuilds:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_DISCORD_GUILDS_GQL,
            operation_name="QueryDiscordGuilds",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryDiscordGuilds.model_validate(data)

    async def query_dropbox_folders(
        self,
        properties: DropboxFoldersInput,
        folder_path: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryDropboxFolders:
        variables: dict[str, object] = {
            "properties": properties,
            "folderPath": folder_path,
        }
        response = await self.execute(
            query=QUERY_DROPBOX_FOLDERS_GQL,
            operation_name="QueryDropboxFolders",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryDropboxFolders.model_validate(data)

    async def query_feeds(
        self,
        filter: Union[Optional[FeedFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryFeeds:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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_git_hub_repositories(
        self,
        properties: GitHubRepositoriesInput,
        sort_by: Union[Optional[GitHubRepositorySortTypes], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryGitHubRepositories:
        variables: dict[str, object] = {"properties": properties, "sortBy": sort_by}
        response = await self.execute(
            query=QUERY_GIT_HUB_REPOSITORIES_GQL,
            operation_name="QueryGitHubRepositories",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryGitHubRepositories.model_validate(data)

    async def query_google_calendars(
        self, properties: GoogleCalendarsInput, **kwargs: Any
    ) -> QueryGoogleCalendars:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_GOOGLE_CALENDARS_GQL,
            operation_name="QueryGoogleCalendars",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryGoogleCalendars.model_validate(data)

    async def query_google_drive_drives(
        self, properties: GoogleDriveDrivesInput, **kwargs: Any
    ) -> QueryGoogleDriveDrives:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_GOOGLE_DRIVE_DRIVES_GQL,
            operation_name="QueryGoogleDriveDrives",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryGoogleDriveDrives.model_validate(data)

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

    async def query_gusto_companies(
        self, properties: GustoCompaniesInput, **kwargs: Any
    ) -> QueryGustoCompanies:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_GUSTO_COMPANIES_GQL,
            operation_name="QueryGustoCompanies",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryGustoCompanies.model_validate(data)

    async def query_gusto_departments(
        self, properties: GustoOptionsInput, **kwargs: Any
    ) -> QueryGustoDepartments:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_GUSTO_DEPARTMENTS_GQL,
            operation_name="QueryGustoDepartments",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryGustoDepartments.model_validate(data)

    async def query_gusto_locations(
        self, properties: GustoOptionsInput, **kwargs: Any
    ) -> QueryGustoLocations:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_GUSTO_LOCATIONS_GQL,
            operation_name="QueryGustoLocations",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryGustoLocations.model_validate(data)

    async def query_jira_projects(
        self, properties: JiraProjectsInput, **kwargs: Any
    ) -> QueryJiraProjects:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_JIRA_PROJECTS_GQL,
            operation_name="QueryJiraProjects",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryJiraProjects.model_validate(data)

    async def query_linear_projects(
        self, properties: LinearProjectsInput, **kwargs: Any
    ) -> QueryLinearProjects:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_LINEAR_PROJECTS_GQL,
            operation_name="QueryLinearProjects",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryLinearProjects.model_validate(data)

    async def query_microsoft_calendars(
        self, properties: MicrosoftCalendarsInput, **kwargs: Any
    ) -> QueryMicrosoftCalendars:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_MICROSOFT_CALENDARS_GQL,
            operation_name="QueryMicrosoftCalendars",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMicrosoftCalendars.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_monday_boards(
        self, properties: MondayBoardsInput, **kwargs: Any
    ) -> QueryMondayBoards:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_MONDAY_BOARDS_GQL,
            operation_name="QueryMondayBoards",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMondayBoards.model_validate(data)

    async def query_notion_databases(
        self, properties: NotionDatabasesInput, **kwargs: Any
    ) -> QueryNotionDatabases:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_NOTION_DATABASES_GQL,
            operation_name="QueryNotionDatabases",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryNotionDatabases.model_validate(data)

    async def query_notion_pages(
        self, properties: NotionPagesInput, identifier: str, **kwargs: Any
    ) -> QueryNotionPages:
        variables: dict[str, object] = {
            "properties": properties,
            "identifier": identifier,
        }
        response = await self.execute(
            query=QUERY_NOTION_PAGES_GQL,
            operation_name="QueryNotionPages",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryNotionPages.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,
        library_id: str,
        folder_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QuerySharePointFolders:
        variables: dict[str, object] = {
            "properties": properties,
            "libraryId": library_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 query_slack_channels(
        self, properties: SlackChannelsInput, **kwargs: Any
    ) -> QuerySlackChannels:
        variables: dict[str, object] = {"properties": properties}
        response = await self.execute(
            query=QUERY_SLACK_CHANNELS_GQL,
            operation_name="QuerySlackChannels",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QuerySlackChannels.model_validate(data)

    async def trigger_feed(self, id: str, **kwargs: Any) -> TriggerFeed:
        variables: dict[str, object] = {"id": id}
        response = await self.execute(
            query=TRIGGER_FEED_GQL,
            operation_name="TriggerFeed",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return TriggerFeed.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_investments(
        self,
        filter: Union[Optional[InvestmentFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountInvestments:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_INVESTMENTS_GQL,
            operation_name="CountInvestments",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountInvestments.model_validate(data)

    async def create_investment(
        self, investment: InvestmentInput, **kwargs: Any
    ) -> CreateInvestment:
        variables: dict[str, object] = {"investment": investment}
        response = await self.execute(
            query=CREATE_INVESTMENT_GQL,
            operation_name="CreateInvestment",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateInvestment.model_validate(data)

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

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

    async def delete_investments(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteInvestments:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_INVESTMENTS_GQL,
            operation_name="DeleteInvestments",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteInvestments.model_validate(data)

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

    async def query_investments(
        self,
        filter: Union[Optional[InvestmentFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryInvestments:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_INVESTMENTS_GQL,
            operation_name="QueryInvestments",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryInvestments.model_validate(data)

    async def query_investments_clusters(
        self,
        filter: Union[Optional[InvestmentFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryInvestmentsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_INVESTMENTS_CLUSTERS_GQL,
            operation_name="QueryInvestmentsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryInvestmentsClusters.model_validate(data)

    async def query_investments_expanded(
        self,
        filter: Union[Optional[InvestmentFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryInvestmentsExpanded:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_INVESTMENTS_EXPANDED_GQL,
            operation_name="QueryInvestmentsExpanded",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryInvestmentsExpanded.model_validate(data)

    async def update_investment(
        self, investment: InvestmentUpdateInput, **kwargs: Any
    ) -> UpdateInvestment:
        variables: dict[str, object] = {"investment": investment}
        response = await self.execute(
            query=UPDATE_INVESTMENT_GQL,
            operation_name="UpdateInvestment",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateInvestment.model_validate(data)

    async def count_investment_funds(
        self,
        filter: Union[Optional[InvestmentFundFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountInvestmentFunds:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_INVESTMENT_FUNDS_GQL,
            operation_name="CountInvestmentFunds",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountInvestmentFunds.model_validate(data)

    async def create_investment_fund(
        self, investment_fund: InvestmentFundInput, **kwargs: Any
    ) -> CreateInvestmentFund:
        variables: dict[str, object] = {"investmentFund": investment_fund}
        response = await self.execute(
            query=CREATE_INVESTMENT_FUND_GQL,
            operation_name="CreateInvestmentFund",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateInvestmentFund.model_validate(data)

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

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

    async def delete_investment_funds(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteInvestmentFunds:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_INVESTMENT_FUNDS_GQL,
            operation_name="DeleteInvestmentFunds",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteInvestmentFunds.model_validate(data)

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

    async def query_investment_funds(
        self,
        filter: Union[Optional[InvestmentFundFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryInvestmentFunds:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_INVESTMENT_FUNDS_GQL,
            operation_name="QueryInvestmentFunds",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryInvestmentFunds.model_validate(data)

    async def query_investment_funds_clusters(
        self,
        filter: Union[Optional[InvestmentFundFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryInvestmentFundsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_INVESTMENT_FUNDS_CLUSTERS_GQL,
            operation_name="QueryInvestmentFundsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryInvestmentFundsClusters.model_validate(data)

    async def query_investment_funds_expanded(
        self,
        filter: Union[Optional[InvestmentFundFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryInvestmentFundsExpanded:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_INVESTMENT_FUNDS_EXPANDED_GQL,
            operation_name="QueryInvestmentFundsExpanded",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryInvestmentFundsExpanded.model_validate(data)

    async def update_investment_fund(
        self, investment_fund: InvestmentFundUpdateInput, **kwargs: Any
    ) -> UpdateInvestmentFund:
        variables: dict[str, object] = {"investmentFund": investment_fund}
        response = await self.execute(
            query=UPDATE_INVESTMENT_FUND_GQL,
            operation_name="UpdateInvestmentFund",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateInvestmentFund.model_validate(data)

    async def count_labels(
        self,
        filter: Union[Optional[LabelFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountLabels:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetLabel:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryLabels:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 upsert_label(self, label: LabelInput, **kwargs: Any) -> UpsertLabel:
        variables: dict[str, object] = {"label": label}
        response = await self.execute(
            query=UPSERT_LABEL_GQL,
            operation_name="UpsertLabel",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpsertLabel.model_validate(data)

    async def count_medical_conditions(
        self,
        filter: Union[Optional[MedicalConditionFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountMedicalConditions:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_MEDICAL_CONDITIONS_GQL,
            operation_name="CountMedicalConditions",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountMedicalConditions.model_validate(data)

    async def create_medical_condition(
        self, medical_condition: MedicalConditionInput, **kwargs: Any
    ) -> CreateMedicalCondition:
        variables: dict[str, object] = {"medicalCondition": medical_condition}
        response = await self.execute(
            query=CREATE_MEDICAL_CONDITION_GQL,
            operation_name="CreateMedicalCondition",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateMedicalCondition.model_validate(data)

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

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

    async def delete_medical_conditions(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteMedicalConditions:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_MEDICAL_CONDITIONS_GQL,
            operation_name="DeleteMedicalConditions",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteMedicalConditions.model_validate(data)

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

    async def query_medical_conditions(
        self,
        filter: Union[Optional[MedicalConditionFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalConditions:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_CONDITIONS_GQL,
            operation_name="QueryMedicalConditions",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalConditions.model_validate(data)

    async def query_medical_conditions_clusters(
        self,
        filter: Union[Optional[MedicalConditionFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalConditionsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_CONDITIONS_CLUSTERS_GQL,
            operation_name="QueryMedicalConditionsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalConditionsClusters.model_validate(data)

    async def update_medical_condition(
        self, medical_condition: MedicalConditionUpdateInput, **kwargs: Any
    ) -> UpdateMedicalCondition:
        variables: dict[str, object] = {"medicalCondition": medical_condition}
        response = await self.execute(
            query=UPDATE_MEDICAL_CONDITION_GQL,
            operation_name="UpdateMedicalCondition",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateMedicalCondition.model_validate(data)

    async def count_medical_contraindications(
        self,
        filter: Union[Optional[MedicalContraindicationFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountMedicalContraindications:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_MEDICAL_CONTRAINDICATIONS_GQL,
            operation_name="CountMedicalContraindications",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountMedicalContraindications.model_validate(data)

    async def create_medical_contraindication(
        self, medical_contraindication: MedicalContraindicationInput, **kwargs: Any
    ) -> CreateMedicalContraindication:
        variables: dict[str, object] = {
            "medicalContraindication": medical_contraindication
        }
        response = await self.execute(
            query=CREATE_MEDICAL_CONTRAINDICATION_GQL,
            operation_name="CreateMedicalContraindication",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateMedicalContraindication.model_validate(data)

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

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

    async def delete_medical_contraindications(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteMedicalContraindications:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_MEDICAL_CONTRAINDICATIONS_GQL,
            operation_name="DeleteMedicalContraindications",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteMedicalContraindications.model_validate(data)

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

    async def query_medical_contraindications(
        self,
        filter: Union[Optional[MedicalContraindicationFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalContraindications:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_CONTRAINDICATIONS_GQL,
            operation_name="QueryMedicalContraindications",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalContraindications.model_validate(data)

    async def query_medical_contraindications_clusters(
        self,
        filter: Union[Optional[MedicalContraindicationFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalContraindicationsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_CONTRAINDICATIONS_CLUSTERS_GQL,
            operation_name="QueryMedicalContraindicationsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalContraindicationsClusters.model_validate(data)

    async def update_medical_contraindication(
        self,
        medical_contraindication: MedicalContraindicationUpdateInput,
        **kwargs: Any
    ) -> UpdateMedicalContraindication:
        variables: dict[str, object] = {
            "medicalContraindication": medical_contraindication
        }
        response = await self.execute(
            query=UPDATE_MEDICAL_CONTRAINDICATION_GQL,
            operation_name="UpdateMedicalContraindication",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateMedicalContraindication.model_validate(data)

    async def count_medical_devices(
        self,
        filter: Union[Optional[MedicalDeviceFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountMedicalDevices:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_MEDICAL_DEVICES_GQL,
            operation_name="CountMedicalDevices",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountMedicalDevices.model_validate(data)

    async def create_medical_device(
        self, medical_device: MedicalDeviceInput, **kwargs: Any
    ) -> CreateMedicalDevice:
        variables: dict[str, object] = {"medicalDevice": medical_device}
        response = await self.execute(
            query=CREATE_MEDICAL_DEVICE_GQL,
            operation_name="CreateMedicalDevice",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateMedicalDevice.model_validate(data)

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

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

    async def delete_medical_devices(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteMedicalDevices:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_MEDICAL_DEVICES_GQL,
            operation_name="DeleteMedicalDevices",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteMedicalDevices.model_validate(data)

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

    async def query_medical_devices(
        self,
        filter: Union[Optional[MedicalDeviceFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalDevices:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_DEVICES_GQL,
            operation_name="QueryMedicalDevices",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalDevices.model_validate(data)

    async def query_medical_devices_clusters(
        self,
        filter: Union[Optional[MedicalDeviceFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalDevicesClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_DEVICES_CLUSTERS_GQL,
            operation_name="QueryMedicalDevicesClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalDevicesClusters.model_validate(data)

    async def update_medical_device(
        self, medical_device: MedicalDeviceUpdateInput, **kwargs: Any
    ) -> UpdateMedicalDevice:
        variables: dict[str, object] = {"medicalDevice": medical_device}
        response = await self.execute(
            query=UPDATE_MEDICAL_DEVICE_GQL,
            operation_name="UpdateMedicalDevice",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateMedicalDevice.model_validate(data)

    async def count_medical_drugs(
        self,
        filter: Union[Optional[MedicalDrugFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountMedicalDrugs:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_MEDICAL_DRUGS_GQL,
            operation_name="CountMedicalDrugs",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountMedicalDrugs.model_validate(data)

    async def create_medical_drug(
        self, medical_drug: MedicalDrugInput, **kwargs: Any
    ) -> CreateMedicalDrug:
        variables: dict[str, object] = {"medicalDrug": medical_drug}
        response = await self.execute(
            query=CREATE_MEDICAL_DRUG_GQL,
            operation_name="CreateMedicalDrug",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateMedicalDrug.model_validate(data)

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

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

    async def delete_medical_drugs(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteMedicalDrugs:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_MEDICAL_DRUGS_GQL,
            operation_name="DeleteMedicalDrugs",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteMedicalDrugs.model_validate(data)

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

    async def query_medical_drugs(
        self,
        filter: Union[Optional[MedicalDrugFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalDrugs:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_DRUGS_GQL,
            operation_name="QueryMedicalDrugs",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalDrugs.model_validate(data)

    async def query_medical_drugs_clusters(
        self,
        filter: Union[Optional[MedicalDrugFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalDrugsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_DRUGS_CLUSTERS_GQL,
            operation_name="QueryMedicalDrugsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalDrugsClusters.model_validate(data)

    async def update_medical_drug(
        self, medical_drug: MedicalDrugUpdateInput, **kwargs: Any
    ) -> UpdateMedicalDrug:
        variables: dict[str, object] = {"medicalDrug": medical_drug}
        response = await self.execute(
            query=UPDATE_MEDICAL_DRUG_GQL,
            operation_name="UpdateMedicalDrug",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateMedicalDrug.model_validate(data)

    async def count_medical_drug_classes(
        self,
        filter: Union[Optional[MedicalDrugClassFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountMedicalDrugClasses:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_MEDICAL_DRUG_CLASSES_GQL,
            operation_name="CountMedicalDrugClasses",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountMedicalDrugClasses.model_validate(data)

    async def create_medical_drug_class(
        self, medical_drug_class: MedicalDrugClassInput, **kwargs: Any
    ) -> CreateMedicalDrugClass:
        variables: dict[str, object] = {"medicalDrugClass": medical_drug_class}
        response = await self.execute(
            query=CREATE_MEDICAL_DRUG_CLASS_GQL,
            operation_name="CreateMedicalDrugClass",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateMedicalDrugClass.model_validate(data)

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

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

    async def delete_medical_drug_classes(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteMedicalDrugClasses:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_MEDICAL_DRUG_CLASSES_GQL,
            operation_name="DeleteMedicalDrugClasses",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteMedicalDrugClasses.model_validate(data)

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

    async def query_medical_drug_classes(
        self,
        filter: Union[Optional[MedicalDrugClassFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalDrugClasses:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_DRUG_CLASSES_GQL,
            operation_name="QueryMedicalDrugClasses",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalDrugClasses.model_validate(data)

    async def query_medical_drug_classes_clusters(
        self,
        filter: Union[Optional[MedicalDrugClassFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalDrugClassesClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_DRUG_CLASSES_CLUSTERS_GQL,
            operation_name="QueryMedicalDrugClassesClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalDrugClassesClusters.model_validate(data)

    async def update_medical_drug_class(
        self, medical_drug_class: MedicalDrugClassUpdateInput, **kwargs: Any
    ) -> UpdateMedicalDrugClass:
        variables: dict[str, object] = {"medicalDrugClass": medical_drug_class}
        response = await self.execute(
            query=UPDATE_MEDICAL_DRUG_CLASS_GQL,
            operation_name="UpdateMedicalDrugClass",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateMedicalDrugClass.model_validate(data)

    async def count_medical_guidelines(
        self,
        filter: Union[Optional[MedicalGuidelineFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountMedicalGuidelines:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_MEDICAL_GUIDELINES_GQL,
            operation_name="CountMedicalGuidelines",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountMedicalGuidelines.model_validate(data)

    async def create_medical_guideline(
        self, medical_guideline: MedicalGuidelineInput, **kwargs: Any
    ) -> CreateMedicalGuideline:
        variables: dict[str, object] = {"medicalGuideline": medical_guideline}
        response = await self.execute(
            query=CREATE_MEDICAL_GUIDELINE_GQL,
            operation_name="CreateMedicalGuideline",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateMedicalGuideline.model_validate(data)

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

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

    async def delete_medical_guidelines(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteMedicalGuidelines:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_MEDICAL_GUIDELINES_GQL,
            operation_name="DeleteMedicalGuidelines",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteMedicalGuidelines.model_validate(data)

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

    async def query_medical_guidelines(
        self,
        filter: Union[Optional[MedicalGuidelineFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalGuidelines:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_GUIDELINES_GQL,
            operation_name="QueryMedicalGuidelines",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalGuidelines.model_validate(data)

    async def query_medical_guidelines_clusters(
        self,
        filter: Union[Optional[MedicalGuidelineFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalGuidelinesClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_GUIDELINES_CLUSTERS_GQL,
            operation_name="QueryMedicalGuidelinesClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalGuidelinesClusters.model_validate(data)

    async def update_medical_guideline(
        self, medical_guideline: MedicalGuidelineUpdateInput, **kwargs: Any
    ) -> UpdateMedicalGuideline:
        variables: dict[str, object] = {"medicalGuideline": medical_guideline}
        response = await self.execute(
            query=UPDATE_MEDICAL_GUIDELINE_GQL,
            operation_name="UpdateMedicalGuideline",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateMedicalGuideline.model_validate(data)

    async def count_medical_indications(
        self,
        filter: Union[Optional[MedicalIndicationFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountMedicalIndications:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_MEDICAL_INDICATIONS_GQL,
            operation_name="CountMedicalIndications",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountMedicalIndications.model_validate(data)

    async def create_medical_indication(
        self, medical_indication: MedicalIndicationInput, **kwargs: Any
    ) -> CreateMedicalIndication:
        variables: dict[str, object] = {"medicalIndication": medical_indication}
        response = await self.execute(
            query=CREATE_MEDICAL_INDICATION_GQL,
            operation_name="CreateMedicalIndication",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateMedicalIndication.model_validate(data)

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

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

    async def delete_medical_indications(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteMedicalIndications:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_MEDICAL_INDICATIONS_GQL,
            operation_name="DeleteMedicalIndications",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteMedicalIndications.model_validate(data)

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

    async def query_medical_indications(
        self,
        filter: Union[Optional[MedicalIndicationFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalIndications:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_INDICATIONS_GQL,
            operation_name="QueryMedicalIndications",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalIndications.model_validate(data)

    async def query_medical_indications_clusters(
        self,
        filter: Union[Optional[MedicalIndicationFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalIndicationsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_INDICATIONS_CLUSTERS_GQL,
            operation_name="QueryMedicalIndicationsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalIndicationsClusters.model_validate(data)

    async def update_medical_indication(
        self, medical_indication: MedicalIndicationUpdateInput, **kwargs: Any
    ) -> UpdateMedicalIndication:
        variables: dict[str, object] = {"medicalIndication": medical_indication}
        response = await self.execute(
            query=UPDATE_MEDICAL_INDICATION_GQL,
            operation_name="UpdateMedicalIndication",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateMedicalIndication.model_validate(data)

    async def count_medical_procedures(
        self,
        filter: Union[Optional[MedicalProcedureFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountMedicalProcedures:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_MEDICAL_PROCEDURES_GQL,
            operation_name="CountMedicalProcedures",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountMedicalProcedures.model_validate(data)

    async def create_medical_procedure(
        self, medical_procedure: MedicalProcedureInput, **kwargs: Any
    ) -> CreateMedicalProcedure:
        variables: dict[str, object] = {"medicalProcedure": medical_procedure}
        response = await self.execute(
            query=CREATE_MEDICAL_PROCEDURE_GQL,
            operation_name="CreateMedicalProcedure",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateMedicalProcedure.model_validate(data)

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

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

    async def delete_medical_procedures(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteMedicalProcedures:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_MEDICAL_PROCEDURES_GQL,
            operation_name="DeleteMedicalProcedures",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteMedicalProcedures.model_validate(data)

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

    async def query_medical_procedures(
        self,
        filter: Union[Optional[MedicalProcedureFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalProcedures:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_PROCEDURES_GQL,
            operation_name="QueryMedicalProcedures",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalProcedures.model_validate(data)

    async def query_medical_procedures_clusters(
        self,
        filter: Union[Optional[MedicalProcedureFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalProceduresClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_PROCEDURES_CLUSTERS_GQL,
            operation_name="QueryMedicalProceduresClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalProceduresClusters.model_validate(data)

    async def update_medical_procedure(
        self, medical_procedure: MedicalProcedureUpdateInput, **kwargs: Any
    ) -> UpdateMedicalProcedure:
        variables: dict[str, object] = {"medicalProcedure": medical_procedure}
        response = await self.execute(
            query=UPDATE_MEDICAL_PROCEDURE_GQL,
            operation_name="UpdateMedicalProcedure",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateMedicalProcedure.model_validate(data)

    async def count_medical_studies(
        self,
        filter: Union[Optional[MedicalStudyFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountMedicalStudies:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_MEDICAL_STUDIES_GQL,
            operation_name="CountMedicalStudies",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountMedicalStudies.model_validate(data)

    async def create_medical_study(
        self, medical_study: MedicalStudyInput, **kwargs: Any
    ) -> CreateMedicalStudy:
        variables: dict[str, object] = {"medicalStudy": medical_study}
        response = await self.execute(
            query=CREATE_MEDICAL_STUDY_GQL,
            operation_name="CreateMedicalStudy",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateMedicalStudy.model_validate(data)

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

    async def delete_medical_studies(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteMedicalStudies:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_MEDICAL_STUDIES_GQL,
            operation_name="DeleteMedicalStudies",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteMedicalStudies.model_validate(data)

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

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

    async def query_medical_studies(
        self,
        filter: Union[Optional[MedicalStudyFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalStudies:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_STUDIES_GQL,
            operation_name="QueryMedicalStudies",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalStudies.model_validate(data)

    async def query_medical_studies_clusters(
        self,
        filter: Union[Optional[MedicalStudyFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalStudiesClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_STUDIES_CLUSTERS_GQL,
            operation_name="QueryMedicalStudiesClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalStudiesClusters.model_validate(data)

    async def update_medical_study(
        self, medical_study: MedicalStudyUpdateInput, **kwargs: Any
    ) -> UpdateMedicalStudy:
        variables: dict[str, object] = {"medicalStudy": medical_study}
        response = await self.execute(
            query=UPDATE_MEDICAL_STUDY_GQL,
            operation_name="UpdateMedicalStudy",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateMedicalStudy.model_validate(data)

    async def count_medical_tests(
        self,
        filter: Union[Optional[MedicalTestFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountMedicalTests:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_MEDICAL_TESTS_GQL,
            operation_name="CountMedicalTests",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountMedicalTests.model_validate(data)

    async def create_medical_test(
        self, medical_test: MedicalTestInput, **kwargs: Any
    ) -> CreateMedicalTest:
        variables: dict[str, object] = {"medicalTest": medical_test}
        response = await self.execute(
            query=CREATE_MEDICAL_TEST_GQL,
            operation_name="CreateMedicalTest",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateMedicalTest.model_validate(data)

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

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

    async def delete_medical_tests(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteMedicalTests:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_MEDICAL_TESTS_GQL,
            operation_name="DeleteMedicalTests",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteMedicalTests.model_validate(data)

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

    async def query_medical_tests(
        self,
        filter: Union[Optional[MedicalTestFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalTests:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_TESTS_GQL,
            operation_name="QueryMedicalTests",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalTests.model_validate(data)

    async def query_medical_tests_clusters(
        self,
        filter: Union[Optional[MedicalTestFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalTestsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_TESTS_CLUSTERS_GQL,
            operation_name="QueryMedicalTestsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalTestsClusters.model_validate(data)

    async def update_medical_test(
        self, medical_test: MedicalTestUpdateInput, **kwargs: Any
    ) -> UpdateMedicalTest:
        variables: dict[str, object] = {"medicalTest": medical_test}
        response = await self.execute(
            query=UPDATE_MEDICAL_TEST_GQL,
            operation_name="UpdateMedicalTest",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateMedicalTest.model_validate(data)

    async def count_medical_therapies(
        self,
        filter: Union[Optional[MedicalTherapyFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountMedicalTherapies:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_MEDICAL_THERAPIES_GQL,
            operation_name="CountMedicalTherapies",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountMedicalTherapies.model_validate(data)

    async def create_medical_therapy(
        self, medical_therapy: MedicalTherapyInput, **kwargs: Any
    ) -> CreateMedicalTherapy:
        variables: dict[str, object] = {"medicalTherapy": medical_therapy}
        response = await self.execute(
            query=CREATE_MEDICAL_THERAPY_GQL,
            operation_name="CreateMedicalTherapy",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateMedicalTherapy.model_validate(data)

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

    async def delete_medical_therapies(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteMedicalTherapies:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_MEDICAL_THERAPIES_GQL,
            operation_name="DeleteMedicalTherapies",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteMedicalTherapies.model_validate(data)

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

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

    async def query_medical_therapies(
        self,
        filter: Union[Optional[MedicalTherapyFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalTherapies:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_THERAPIES_GQL,
            operation_name="QueryMedicalTherapies",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalTherapies.model_validate(data)

    async def query_medical_therapies_clusters(
        self,
        filter: Union[Optional[MedicalTherapyFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryMedicalTherapiesClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_MEDICAL_THERAPIES_CLUSTERS_GQL,
            operation_name="QueryMedicalTherapiesClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryMedicalTherapiesClusters.model_validate(data)

    async def update_medical_therapy(
        self, medical_therapy: MedicalTherapyUpdateInput, **kwargs: Any
    ) -> UpdateMedicalTherapy:
        variables: dict[str, object] = {"medicalTherapy": medical_therapy}
        response = await self.execute(
            query=UPDATE_MEDICAL_THERAPY_GQL,
            operation_name="UpdateMedicalTherapy",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateMedicalTherapy.model_validate(data)

    async def send_notification(
        self,
        connector: IntegrationConnectorInput,
        text: str,
        text_type: Union[Optional[TextTypes], UnsetType] = UNSET,
        **kwargs: Any
    ) -> SendNotification:
        variables: dict[str, object] = {
            "connector": connector,
            "text": text,
            "textType": text_type,
        }
        response = await self.execute(
            query=SEND_NOTIFICATION_GQL,
            operation_name="SendNotification",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return SendNotification.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 match_entity(
        self,
        observable: ObservableInput,
        candidates: list[EntityReferenceInput],
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> MatchEntity:
        variables: dict[str, object] = {
            "observable": observable,
            "candidates": candidates,
            "specification": specification,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=MATCH_ENTITY_GQL,
            operation_name="MatchEntity",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return MatchEntity.model_validate(data)

    async def resolve_entities(
        self,
        type: ObservableTypes,
        entities: list[EntityReferenceInput],
        threshold: Union[Optional[float], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ResolveEntities:
        variables: dict[str, object] = {
            "type": type,
            "entities": entities,
            "threshold": threshold,
            "specification": specification,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=RESOLVE_ENTITIES_GQL,
            operation_name="ResolveEntities",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ResolveEntities.model_validate(data)

    async def resolve_entity(
        self,
        type: ObservableTypes,
        source: EntityReferenceInput,
        target: EntityReferenceInput,
        specification: Union[Optional[EntityReferenceInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ResolveEntity:
        variables: dict[str, object] = {
            "type": type,
            "source": source,
            "target": target,
            "specification": specification,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=RESOLVE_ENTITY_GQL,
            operation_name="ResolveEntity",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ResolveEntity.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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountOrganizations:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 enrich_organizations(
        self,
        connector: EntityEnrichmentConnectorInput,
        filter: Union[Optional[OrganizationFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> EnrichOrganizations:
        variables: dict[str, object] = {
            "filter": filter,
            "connector": connector,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=ENRICH_ORGANIZATIONS_GQL,
            operation_name="EnrichOrganizations",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return EnrichOrganizations.model_validate(data)

    async def get_organization(
        self,
        id: str,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetOrganization:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryOrganizations:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 query_organizations_clusters(
        self,
        filter: Union[Optional[OrganizationFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryOrganizationsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_ORGANIZATIONS_CLUSTERS_GQL,
            operation_name="QueryOrganizationsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryOrganizationsClusters.model_validate(data)

    async def query_organizations_expanded(
        self,
        filter: Union[Optional[OrganizationFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryOrganizationsExpanded:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_ORGANIZATIONS_EXPANDED_GQL,
            operation_name="QueryOrganizationsExpanded",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryOrganizationsExpanded.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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountPersons:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 enrich_persons(
        self,
        connector: EntityEnrichmentConnectorInput,
        filter: Union[Optional[PersonFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> EnrichPersons:
        variables: dict[str, object] = {
            "filter": filter,
            "connector": connector,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=ENRICH_PERSONS_GQL,
            operation_name="EnrichPersons",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return EnrichPersons.model_validate(data)

    async def get_person(
        self,
        id: str,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetPerson:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryPersons:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 query_persons_clusters(
        self,
        filter: Union[Optional[PersonFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryPersonsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_PERSONS_CLUSTERS_GQL,
            operation_name="QueryPersonsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryPersonsClusters.model_validate(data)

    async def query_persons_expanded(
        self,
        filter: Union[Optional[PersonFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryPersonsExpanded:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_PERSONS_EXPANDED_GQL,
            operation_name="QueryPersonsExpanded",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryPersonsExpanded.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_personas(
        self,
        filter: Union[Optional[PersonaFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountPersonas:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_PERSONAS_GQL,
            operation_name="CountPersonas",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountPersonas.model_validate(data)

    async def create_persona(
        self, persona: PersonaInput, **kwargs: Any
    ) -> CreatePersona:
        variables: dict[str, object] = {"persona": persona}
        response = await self.execute(
            query=CREATE_PERSONA_GQL,
            operation_name="CreatePersona",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreatePersona.model_validate(data)

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

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

    async def delete_personas(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeletePersonas:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_PERSONAS_GQL,
            operation_name="DeletePersonas",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeletePersonas.model_validate(data)

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

    async def query_personas(
        self,
        filter: Union[Optional[PersonaFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryPersonas:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_PERSONAS_GQL,
            operation_name="QueryPersonas",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryPersonas.model_validate(data)

    async def update_persona(
        self, persona: PersonaUpdateInput, **kwargs: Any
    ) -> UpdatePersona:
        variables: dict[str, object] = {"persona": persona}
        response = await self.execute(
            query=UPDATE_PERSONA_GQL,
            operation_name="UpdatePersona",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdatePersona.model_validate(data)

    async def count_places(
        self,
        filter: Union[Optional[PlaceFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountPlaces:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 enrich_places(
        self,
        connector: EntityEnrichmentConnectorInput,
        filter: Union[Optional[PlaceFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> EnrichPlaces:
        variables: dict[str, object] = {
            "filter": filter,
            "connector": connector,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=ENRICH_PLACES_GQL,
            operation_name="EnrichPlaces",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return EnrichPlaces.model_validate(data)

    async def get_place(
        self,
        id: str,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetPlace:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryPlaces:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 query_places_clusters(
        self,
        filter: Union[Optional[PlaceFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryPlacesClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_PLACES_CLUSTERS_GQL,
            operation_name="QueryPlacesClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryPlacesClusters.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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountProducts:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 enrich_products(
        self,
        connector: EntityEnrichmentConnectorInput,
        filter: Union[Optional[ProductFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> EnrichProducts:
        variables: dict[str, object] = {
            "filter": filter,
            "connector": connector,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=ENRICH_PRODUCTS_GQL,
            operation_name="EnrichProducts",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return EnrichProducts.model_validate(data)

    async def get_product(
        self,
        id: str,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetProduct:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryProducts:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 query_products_clusters(
        self,
        filter: Union[Optional[ProductFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryProductsClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_PRODUCTS_CLUSTERS_GQL,
            operation_name="QueryProductsClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryProductsClusters.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,
        start_date: Union[Optional[Any], UnsetType] = UNSET,
        duration: Union[Optional[Any], UnsetType] = UNSET,
        **kwargs: Any
    ) -> LookupCredits:
        variables: dict[str, object] = {
            "correlationId": correlation_id,
            "startDate": start_date,
            "duration": duration,
        }
        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,
        start_date: Union[Optional[Any], UnsetType] = UNSET,
        duration: Union[Optional[Any], UnsetType] = UNSET,
        **kwargs: Any
    ) -> LookupUsage:
        variables: dict[str, object] = {
            "correlationId": correlation_id,
            "startDate": start_date,
            "duration": duration,
        }
        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_tokens(
        self, start_date: Any, duration: Any, **kwargs: Any
    ) -> QueryTokens:
        variables: dict[str, object] = {"startDate": start_date, "duration": duration}
        response = await self.execute(
            query=QUERY_TOKENS_GQL,
            operation_name="QueryTokens",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryTokens.model_validate(data)

    async def query_usage(
        self,
        start_date: Any,
        duration: Any,
        names: Union[Optional[list[str]], UnsetType] = UNSET,
        excluded_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,
            "excludedNames": excluded_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountRepos:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetRepo:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryRepos:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 query_repos_clusters(
        self,
        filter: Union[Optional[RepoFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryReposClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_REPOS_CLUSTERS_GQL,
            operation_name="QueryReposClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryReposClusters.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 map_web(
        self,
        uri: Any,
        allowed_paths: Union[Optional[list[str]], UnsetType] = UNSET,
        excluded_paths: Union[Optional[list[str]], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> MapWeb:
        variables: dict[str, object] = {
            "uri": uri,
            "allowedPaths": allowed_paths,
            "excludedPaths": excluded_paths,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=MAP_WEB_GQL, operation_name="MapWeb", variables=variables, **kwargs
        )
        data = self.get_data(response)
        return MapWeb.model_validate(data)

    async def search_web(
        self,
        text: str,
        service: Union[Optional[SearchServiceTypes], UnsetType] = UNSET,
        limit: Union[Optional[int], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> SearchWeb:
        variables: dict[str, object] = {
            "text": text,
            "service": service,
            "limit": limit,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=SEARCH_WEB_GQL,
            operation_name="SearchWeb",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return SearchWeb.model_validate(data)

    async def count_skills(
        self,
        filter: Union[Optional[SkillFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountSkills:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_SKILLS_GQL,
            operation_name="CountSkills",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountSkills.model_validate(data)

    async def create_skill(
        self,
        skill: SkillInput,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CreateSkill:
        variables: dict[str, object] = {"skill": skill, "correlationId": correlation_id}
        response = await self.execute(
            query=CREATE_SKILL_GQL,
            operation_name="CreateSkill",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateSkill.model_validate(data)

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

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

    async def delete_skills(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteSkills:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_SKILLS_GQL,
            operation_name="DeleteSkills",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteSkills.model_validate(data)

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

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

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

    async def query_skills(
        self,
        filter: Union[Optional[SkillFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QuerySkills:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_SKILLS_GQL,
            operation_name="QuerySkills",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QuerySkills.model_validate(data)

    async def update_skill(self, skill: SkillUpdateInput, **kwargs: Any) -> UpdateSkill:
        variables: dict[str, object] = {"skill": skill}
        response = await self.execute(
            query=UPDATE_SKILL_GQL,
            operation_name="UpdateSkill",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateSkill.model_validate(data)

    async def upsert_skill(self, skill: SkillInput, **kwargs: Any) -> UpsertSkill:
        variables: dict[str, object] = {"skill": skill}
        response = await self.execute(
            query=UPSERT_SKILL_GQL,
            operation_name="UpsertSkill",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpsertSkill.model_validate(data)

    async def count_softwares(
        self,
        filter: Union[Optional[SoftwareFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountSoftwares:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetSoftware:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QuerySoftwares:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 query_softwares_clusters(
        self,
        filter: Union[Optional[SoftwareFilter], UnsetType] = UNSET,
        clusters: Union[Optional[EntityClustersInput], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QuerySoftwaresClusters:
        variables: dict[str, object] = {
            "filter": filter,
            "clusters": clusters,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_SOFTWARES_CLUSTERS_GQL,
            operation_name="QuerySoftwaresClusters",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QuerySoftwaresClusters.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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountSpecifications:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetSpecification:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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_models(
        self, filter: Union[Optional[ModelFilter], UnsetType] = UNSET, **kwargs: Any
    ) -> QueryModels:
        variables: dict[str, object] = {"filter": filter}
        response = await self.execute(
            query=QUERY_MODELS_GQL,
            operation_name="QueryModels",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryModels.model_validate(data)

    async def query_specifications(
        self,
        filter: Union[Optional[SpecificationFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QuerySpecifications:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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 specification_exists(
        self,
        filter: Union[Optional[SpecificationFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> SpecificationExists:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=SPECIFICATION_EXISTS_GQL,
            operation_name="SpecificationExists",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return SpecificationExists.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 upsert_specification(
        self, specification: SpecificationInput, **kwargs: Any
    ) -> UpsertSpecification:
        variables: dict[str, object] = {"specification": specification}
        response = await self.execute(
            query=UPSERT_SPECIFICATION_GQL,
            operation_name="UpsertSpecification",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpsertSpecification.model_validate(data)

    async def count_users(
        self,
        filter: Union[Optional[UserFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountUsers:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_USERS_GQL,
            operation_name="CountUsers",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountUsers.model_validate(data)

    async def create_user(self, user: UserInput, **kwargs: Any) -> CreateUser:
        variables: dict[str, object] = {"user": user}
        response = await self.execute(
            query=CREATE_USER_GQL,
            operation_name="CreateUser",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateUser.model_validate(data)

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

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

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

    async def get_user(self, **kwargs: Any) -> GetUser:
        variables: dict[str, object] = {}
        response = await self.execute(
            query=GET_USER_GQL, operation_name="GetUser", variables=variables, **kwargs
        )
        data = self.get_data(response)
        return GetUser.model_validate(data)

    async def get_user_by_identifier(
        self, identifier: str, **kwargs: Any
    ) -> GetUserByIdentifier:
        variables: dict[str, object] = {"identifier": identifier}
        response = await self.execute(
            query=GET_USER_BY_IDENTIFIER_GQL,
            operation_name="GetUserByIdentifier",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return GetUserByIdentifier.model_validate(data)

    async def query_users(
        self,
        filter: Union[Optional[UserFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryUsers:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_USERS_GQL,
            operation_name="QueryUsers",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryUsers.model_validate(data)

    async def update_user(self, user: UserUpdateInput, **kwargs: Any) -> UpdateUser:
        variables: dict[str, object] = {"user": user}
        response = await self.execute(
            query=UPDATE_USER_GQL,
            operation_name="UpdateUser",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateUser.model_validate(data)

    async def count_views(
        self,
        filter: Union[Optional[ViewFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountViews:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=COUNT_VIEWS_GQL,
            operation_name="CountViews",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CountViews.model_validate(data)

    async def create_view(self, view: ViewInput, **kwargs: Any) -> CreateView:
        variables: dict[str, object] = {"view": view}
        response = await self.execute(
            query=CREATE_VIEW_GQL,
            operation_name="CreateView",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return CreateView.model_validate(data)

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

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

    async def delete_views(
        self,
        ids: list[str],
        is_synchronous: Union[Optional[bool], UnsetType] = UNSET,
        **kwargs: Any
    ) -> DeleteViews:
        variables: dict[str, object] = {"ids": ids, "isSynchronous": is_synchronous}
        response = await self.execute(
            query=DELETE_VIEWS_GQL,
            operation_name="DeleteViews",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return DeleteViews.model_validate(data)

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

    async def query_views(
        self,
        filter: Union[Optional[ViewFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryViews:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=QUERY_VIEWS_GQL,
            operation_name="QueryViews",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return QueryViews.model_validate(data)

    async def update_view(self, view: ViewUpdateInput, **kwargs: Any) -> UpdateView:
        variables: dict[str, object] = {"view": view}
        response = await self.execute(
            query=UPDATE_VIEW_GQL,
            operation_name="UpdateView",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateView.model_validate(data)

    async def upsert_view(self, view: ViewInput, **kwargs: Any) -> UpsertView:
        variables: dict[str, object] = {"view": view}
        response = await self.execute(
            query=UPSERT_VIEW_GQL,
            operation_name="UpsertView",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpsertView.model_validate(data)

    async def view_exists(
        self,
        filter: Union[Optional[ViewFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> ViewExists:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=VIEW_EXISTS_GQL,
            operation_name="ViewExists",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return ViewExists.model_validate(data)

    async def count_workflows(
        self,
        filter: Union[Optional[WorkflowFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CountWorkflows:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> GetWorkflow:
        variables: dict[str, object] = {"id": id, "correlationId": correlation_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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> QueryWorkflows:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        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)

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

    async def workflow_exists(
        self,
        filter: Union[Optional[WorkflowFilter], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> WorkflowExists:
        variables: dict[str, object] = {
            "filter": filter,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=WORKFLOW_EXISTS_GQL,
            operation_name="WorkflowExists",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return WorkflowExists.model_validate(data)
