client.py

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

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

from .add_contents_to_collections import AddContentsToCollections
from .ask_graphlit import AskGraphlit
from .async_base_client import AsyncBaseClient
from .base_model import UNSET, UnsetType
from .clear_conversation import ClearConversation
from .close_conversation import CloseConversation
from .complete_conversation import CompleteConversation
from .continue_conversation import ContinueConversation
from .count_alerts import CountAlerts
from .count_categories import CountCategories
from .count_collections import CountCollections
from .count_contents import CountContents
from .count_conversations import CountConversations
from .count_events import CountEvents
from .count_feeds import CountFeeds
from .count_labels import CountLabels
from .count_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_persons import CountPersons
from .count_places import CountPlaces
from .count_products import CountProducts
from .count_repos import CountRepos
from .count_softwares import CountSoftwares
from .count_specifications import CountSpecifications
from .count_users import CountUsers
from .count_workflows import CountWorkflows
from .create_alert import CreateAlert
from .create_category import CreateCategory
from .create_collection import CreateCollection
from .create_conversation import CreateConversation
from .create_event import CreateEvent
from .create_feed import CreateFeed
from .create_label import CreateLabel
from .create_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_place import CreatePlace
from .create_product import CreateProduct
from .create_repo import CreateRepo
from .create_software import CreateSoftware
from .create_specification import CreateSpecification
from .create_user import CreateUser
from .create_workflow import CreateWorkflow
from .delete_alert import DeleteAlert
from .delete_alerts import DeleteAlerts
from .delete_all_alerts import DeleteAllAlerts
from .delete_all_categories import DeleteAllCategories
from .delete_all_collections import DeleteAllCollections
from .delete_all_contents import DeleteAllContents
from .delete_all_conversations import DeleteAllConversations
from .delete_all_events import DeleteAllEvents
from .delete_all_feeds import DeleteAllFeeds
from .delete_all_labels import DeleteAllLabels
from .delete_all_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_persons import DeleteAllPersons
from .delete_all_places import DeleteAllPlaces
from .delete_all_products import DeleteAllProducts
from .delete_all_repos import DeleteAllRepos
from .delete_all_softwares import DeleteAllSoftwares
from .delete_all_specifications import DeleteAllSpecifications
from .delete_all_workflows import DeleteAllWorkflows
from .delete_categories import DeleteCategories
from .delete_category import DeleteCategory
from .delete_collection import DeleteCollection
from .delete_collections import DeleteCollections
from .delete_content import DeleteContent
from .delete_contents import DeleteContents
from .delete_conversation import DeleteConversation
from .delete_conversations import DeleteConversations
from .delete_event import DeleteEvent
from .delete_events import DeleteEvents
from .delete_feed import DeleteFeed
from .delete_feeds import DeleteFeeds
from .delete_label import DeleteLabel
from .delete_labels import DeleteLabels
from .delete_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_persons import DeletePersons
from .delete_place import DeletePlace
from .delete_places import DeletePlaces
from .delete_product import DeleteProduct
from .delete_products import DeleteProducts
from .delete_repo import DeleteRepo
from .delete_repos import DeleteRepos
from .delete_software import DeleteSoftware
from .delete_softwares import DeleteSoftwares
from .delete_specification import DeleteSpecification
from .delete_specifications import DeleteSpecifications
from .delete_user import DeleteUser
from .delete_workflow import DeleteWorkflow
from .delete_workflows import DeleteWorkflows
from .describe_encoded_image import DescribeEncodedImage
from .describe_image import DescribeImage
from .disable_alert import DisableAlert
from .disable_feed import DisableFeed
from .disable_user import DisableUser
from .enable_alert import EnableAlert
from .enable_feed import EnableFeed
from .enable_user import EnableUser
from .enums import SdkTypes, SearchServiceTypes, TextTypes
from .extract_contents import ExtractContents
from .extract_text import ExtractText
from .feed_exists import FeedExists
from .format_conversation import FormatConversation
from .get_alert import GetAlert
from .get_category import GetCategory
from .get_collection import GetCollection
from .get_content import GetContent
from .get_conversation import GetConversation
from .get_event import GetEvent
from .get_feed import GetFeed
from .get_label import GetLabel
from .get_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_place import GetPlace
from .get_product import GetProduct
from .get_project import GetProject
from .get_repo import GetRepo
from .get_share_point_consent_uri import GetSharePointConsentUri
from .get_software import GetSoftware
from .get_specification import GetSpecification
from .get_user import GetUser
from .get_workflow import GetWorkflow
from .ingest_batch import IngestBatch
from .ingest_encoded_file import IngestEncodedFile
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 (
    AlertFilter,
    AlertInput,
    AlertUpdateInput,
    CategoryFilter,
    CategoryInput,
    CategoryUpdateInput,
    CollectionFilter,
    CollectionInput,
    CollectionUpdateInput,
    ContentFacetInput,
    ContentFilter,
    ContentGraphInput,
    ContentPublishingConnectorInput,
    ContentUpdateInput,
    ConversationFilter,
    ConversationInput,
    ConversationMessageInput,
    ConversationToolResponseInput,
    ConversationUpdateInput,
    EntityReferenceInput,
    EventFilter,
    EventInput,
    EventUpdateInput,
    FeedFilter,
    FeedInput,
    FeedUpdateInput,
    IntegrationConnectorInput,
    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,
    MicrosoftTeamsChannelsInput,
    MicrosoftTeamsTeamsInput,
    ModelFilter,
    NotionDatabasesInput,
    NotionPagesInput,
    ObservationInput,
    ObservationReferenceInput,
    ObservationUpdateInput,
    OneDriveFoldersInput,
    OrganizationFilter,
    OrganizationInput,
    OrganizationUpdateInput,
    PersonFilter,
    PersonInput,
    PersonUpdateInput,
    PlaceFilter,
    PlaceInput,
    PlaceUpdateInput,
    ProductFilter,
    ProductInput,
    ProductUpdateInput,
    ProjectUpdateInput,
    RepoFilter,
    RepoInput,
    RepoUpdateInput,
    RerankingStrategyInput,
    RetrievalStrategyInput,
    SharePointFoldersInput,
    SharePointLibrariesInput,
    SlackChannelsInput,
    SoftwareFilter,
    SoftwareInput,
    SoftwareUpdateInput,
    SpecificationFilter,
    SpecificationInput,
    SpecificationUpdateInput,
    SummarizationStrategyInput,
    TextContentInput,
    ToolDefinitionInput,
    UserFilter,
    UserInput,
    UserUpdateInput,
    WorkflowFilter,
    WorkflowInput,
    WorkflowUpdateInput,
)
from .is_content_done import IsContentDone
from .is_feed_done import IsFeedDone
from .lookup_credits import LookupCredits
from .lookup_usage import LookupUsage
from .map_web import MapWeb
from .operations import (
    ADD_CONTENTS_TO_COLLECTIONS_GQL,
    ASK_GRAPHLIT_GQL,
    CLEAR_CONVERSATION_GQL,
    CLOSE_CONVERSATION_GQL,
    COMPLETE_CONVERSATION_GQL,
    CONTINUE_CONVERSATION_GQL,
    COUNT_ALERTS_GQL,
    COUNT_CATEGORIES_GQL,
    COUNT_COLLECTIONS_GQL,
    COUNT_CONTENTS_GQL,
    COUNT_CONVERSATIONS_GQL,
    COUNT_EVENTS_GQL,
    COUNT_FEEDS_GQL,
    COUNT_LABELS_GQL,
    COUNT_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_PERSONS_GQL,
    COUNT_PLACES_GQL,
    COUNT_PRODUCTS_GQL,
    COUNT_REPOS_GQL,
    COUNT_SOFTWARES_GQL,
    COUNT_SPECIFICATIONS_GQL,
    COUNT_USERS_GQL,
    COUNT_WORKFLOWS_GQL,
    CREATE_ALERT_GQL,
    CREATE_CATEGORY_GQL,
    CREATE_COLLECTION_GQL,
    CREATE_CONVERSATION_GQL,
    CREATE_EVENT_GQL,
    CREATE_FEED_GQL,
    CREATE_LABEL_GQL,
    CREATE_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_PLACE_GQL,
    CREATE_PRODUCT_GQL,
    CREATE_REPO_GQL,
    CREATE_SOFTWARE_GQL,
    CREATE_SPECIFICATION_GQL,
    CREATE_USER_GQL,
    CREATE_WORKFLOW_GQL,
    DELETE_ALERT_GQL,
    DELETE_ALERTS_GQL,
    DELETE_ALL_ALERTS_GQL,
    DELETE_ALL_CATEGORIES_GQL,
    DELETE_ALL_COLLECTIONS_GQL,
    DELETE_ALL_CONTENTS_GQL,
    DELETE_ALL_CONVERSATIONS_GQL,
    DELETE_ALL_EVENTS_GQL,
    DELETE_ALL_FEEDS_GQL,
    DELETE_ALL_LABELS_GQL,
    DELETE_ALL_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_PERSONS_GQL,
    DELETE_ALL_PLACES_GQL,
    DELETE_ALL_PRODUCTS_GQL,
    DELETE_ALL_REPOS_GQL,
    DELETE_ALL_SOFTWARES_GQL,
    DELETE_ALL_SPECIFICATIONS_GQL,
    DELETE_ALL_WORKFLOWS_GQL,
    DELETE_CATEGORIES_GQL,
    DELETE_CATEGORY_GQL,
    DELETE_COLLECTION_GQL,
    DELETE_COLLECTIONS_GQL,
    DELETE_CONTENT_GQL,
    DELETE_CONTENTS_GQL,
    DELETE_CONVERSATION_GQL,
    DELETE_CONVERSATIONS_GQL,
    DELETE_EVENT_GQL,
    DELETE_EVENTS_GQL,
    DELETE_FEED_GQL,
    DELETE_FEEDS_GQL,
    DELETE_LABEL_GQL,
    DELETE_LABELS_GQL,
    DELETE_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_PERSONS_GQL,
    DELETE_PLACE_GQL,
    DELETE_PLACES_GQL,
    DELETE_PRODUCT_GQL,
    DELETE_PRODUCTS_GQL,
    DELETE_REPO_GQL,
    DELETE_REPOS_GQL,
    DELETE_SOFTWARE_GQL,
    DELETE_SOFTWARES_GQL,
    DELETE_SPECIFICATION_GQL,
    DELETE_SPECIFICATIONS_GQL,
    DELETE_USER_GQL,
    DELETE_WORKFLOW_GQL,
    DELETE_WORKFLOWS_GQL,
    DESCRIBE_ENCODED_IMAGE_GQL,
    DESCRIBE_IMAGE_GQL,
    DISABLE_ALERT_GQL,
    DISABLE_FEED_GQL,
    DISABLE_USER_GQL,
    ENABLE_ALERT_GQL,
    ENABLE_FEED_GQL,
    ENABLE_USER_GQL,
    EXTRACT_CONTENTS_GQL,
    EXTRACT_TEXT_GQL,
    FEED_EXISTS_GQL,
    FORMAT_CONVERSATION_GQL,
    GET_ALERT_GQL,
    GET_CATEGORY_GQL,
    GET_COLLECTION_GQL,
    GET_CONTENT_GQL,
    GET_CONVERSATION_GQL,
    GET_EVENT_GQL,
    GET_FEED_GQL,
    GET_LABEL_GQL,
    GET_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_PLACE_GQL,
    GET_PRODUCT_GQL,
    GET_PROJECT_GQL,
    GET_REPO_GQL,
    GET_SHARE_POINT_CONSENT_URI_GQL,
    GET_SOFTWARE_GQL,
    GET_SPECIFICATION_GQL,
    GET_USER_GQL,
    GET_WORKFLOW_GQL,
    INGEST_BATCH_GQL,
    INGEST_ENCODED_FILE_GQL,
    INGEST_MEMORY_GQL,
    INGEST_TEXT_BATCH_GQL,
    INGEST_TEXT_GQL,
    INGEST_URI_GQL,
    IS_CONTENT_DONE_GQL,
    IS_FEED_DONE_GQL,
    LOOKUP_CREDITS_GQL,
    LOOKUP_USAGE_GQL,
    MAP_WEB_GQL,
    PROMPT_CONVERSATION_GQL,
    PROMPT_GQL,
    PROMPT_SPECIFICATIONS_GQL,
    PUBLISH_CONTENTS_GQL,
    PUBLISH_CONVERSATION_GQL,
    PUBLISH_TEXT_GQL,
    QUERY_ALERTS_GQL,
    QUERY_CATEGORIES_GQL,
    QUERY_COLLECTIONS_GQL,
    QUERY_CONTENTS_FACETS_GQL,
    QUERY_CONTENTS_GQL,
    QUERY_CONTENTS_GRAPH_GQL,
    QUERY_CONVERSATIONS_GQL,
    QUERY_CREDITS_GQL,
    QUERY_EVENTS_GQL,
    QUERY_FEEDS_GQL,
    QUERY_LABELS_GQL,
    QUERY_LINEAR_PROJECTS_GQL,
    QUERY_MEDICAL_CONDITIONS_GQL,
    QUERY_MEDICAL_CONTRAINDICATIONS_GQL,
    QUERY_MEDICAL_DEVICES_GQL,
    QUERY_MEDICAL_DRUG_CLASSES_GQL,
    QUERY_MEDICAL_DRUGS_GQL,
    QUERY_MEDICAL_GUIDELINES_GQL,
    QUERY_MEDICAL_INDICATIONS_GQL,
    QUERY_MEDICAL_PROCEDURES_GQL,
    QUERY_MEDICAL_STUDIES_GQL,
    QUERY_MEDICAL_TESTS_GQL,
    QUERY_MEDICAL_THERAPIES_GQL,
    QUERY_MICROSOFT_TEAMS_CHANNELS_GQL,
    QUERY_MICROSOFT_TEAMS_TEAMS_GQL,
    QUERY_MODELS_GQL,
    QUERY_NOTION_DATABASES_GQL,
    QUERY_NOTION_PAGES_GQL,
    QUERY_ONE_DRIVE_FOLDERS_GQL,
    QUERY_ORGANIZATIONS_GQL,
    QUERY_PERSONS_GQL,
    QUERY_PLACES_GQL,
    QUERY_PRODUCTS_GQL,
    QUERY_REPOS_GQL,
    QUERY_SHARE_POINT_FOLDERS_GQL,
    QUERY_SHARE_POINT_LIBRARIES_GQL,
    QUERY_SLACK_CHANNELS_GQL,
    QUERY_SOFTWARES_GQL,
    QUERY_SPECIFICATIONS_GQL,
    QUERY_USAGE_GQL,
    QUERY_USERS_GQL,
    QUERY_WORKFLOWS_GQL,
    REMOVE_CONTENTS_FROM_COLLECTION_GQL,
    RETRIEVE_SOURCES_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,
    UPDATE_ALERT_GQL,
    UPDATE_CATEGORY_GQL,
    UPDATE_COLLECTION_GQL,
    UPDATE_CONTENT_GQL,
    UPDATE_CONVERSATION_GQL,
    UPDATE_EVENT_GQL,
    UPDATE_FEED_GQL,
    UPDATE_LABEL_GQL,
    UPDATE_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_PLACE_GQL,
    UPDATE_PRODUCT_GQL,
    UPDATE_PROJECT_GQL,
    UPDATE_REPO_GQL,
    UPDATE_SOFTWARE_GQL,
    UPDATE_SPECIFICATION_GQL,
    UPDATE_USER_GQL,
    UPDATE_WORKFLOW_GQL,
    UPSERT_CATEGORY_GQL,
    UPSERT_LABEL_GQL,
    UPSERT_SPECIFICATION_GQL,
    UPSERT_WORKFLOW_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_alerts import QueryAlerts
from .query_categories import QueryCategories
from .query_collections import QueryCollections
from .query_contents import QueryContents
from .query_contents_facets import QueryContentsFacets
from .query_contents_graph import QueryContentsGraph
from .query_conversations import QueryConversations
from .query_credits import QueryCredits
from .query_events import QueryEvents
from .query_feeds import QueryFeeds
from .query_labels import QueryLabels
from .query_linear_projects import QueryLinearProjects
from .query_medical_conditions import QueryMedicalConditions
from .query_medical_contraindications import QueryMedicalContraindications
from .query_medical_devices import QueryMedicalDevices
from .query_medical_drug_classes import QueryMedicalDrugClasses
from .query_medical_drugs import QueryMedicalDrugs
from .query_medical_guidelines import QueryMedicalGuidelines
from .query_medical_indications import QueryMedicalIndications
from .query_medical_procedures import QueryMedicalProcedures
from .query_medical_studies import QueryMedicalStudies
from .query_medical_tests import QueryMedicalTests
from .query_medical_therapies import QueryMedicalTherapies
from .query_microsoft_teams_channels import QueryMicrosoftTeamsChannels
from .query_microsoft_teams_teams import QueryMicrosoftTeamsTeams
from .query_models import QueryModels
from .query_notion_databases import QueryNotionDatabases
from .query_notion_pages import QueryNotionPages
from .query_one_drive_folders import QueryOneDriveFolders
from .query_organizations import QueryOrganizations
from .query_persons import QueryPersons
from .query_places import QueryPlaces
from .query_products import QueryProducts
from .query_repos import QueryRepos
from .query_share_point_folders import QuerySharePointFolders
from .query_share_point_libraries import QuerySharePointLibraries
from .query_slack_channels import QuerySlackChannels
from .query_softwares import QuerySoftwares
from .query_specifications import QuerySpecifications
from .query_usage import QueryUsage
from .query_users import QueryUsers
from .query_workflows import QueryWorkflows
from .remove_contents_from_collection import RemoveContentsFromCollection
from .retrieve_sources import RetrieveSources
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 .update_alert import UpdateAlert
from .update_category import UpdateCategory
from .update_collection import UpdateCollection
from .update_content import UpdateContent
from .update_conversation import UpdateConversation
from .update_event import UpdateEvent
from .update_feed import UpdateFeed
from .update_label import UpdateLabel
from .update_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_place import UpdatePlace
from .update_product import UpdateProduct
from .update_project import UpdateProject
from .update_repo import UpdateRepo
from .update_software import UpdateSoftware
from .update_specification import UpdateSpecification
from .update_user import UpdateUser
from .update_workflow import UpdateWorkflow
from .upsert_category import UpsertCategory
from .upsert_label import UpsertLabel
from .upsert_specification import UpsertSpecification
from .upsert_workflow import UpsertWorkflow
from .workflow_exists import WorkflowExists


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


class Client(AsyncBaseClient):
    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 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 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 update_collection(
        self, collection: CollectionUpdateInput, **kwargs: Any
    ) -> UpdateCollection:
        variables: Dict[str, object] = {"collection": collection}
        response = await self.execute(
            query=UPDATE_COLLECTION_GQL,
            operation_name="UpdateCollection",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateCollection.model_validate(data)

    async def count_contents(
        self,
        filter: Union[Optional[ContentFilter], UnsetType] = UNSET,
        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 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_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,
        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,
            "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_memory(
        self,
        text: str,
        name: Union[Optional[str], UnsetType] = UNSET,
        text_type: Union[Optional[TextTypes], 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,
            "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,
        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,
            "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,
        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,
            "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 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 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 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,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> CompleteConversation:
        variables: Dict[str, object] = {
            "completion": completion,
            "id": id,
            "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,
        include_details: Union[Optional[bool], UnsetType] = UNSET,
        correlation_id: Union[Optional[str], UnsetType] = UNSET,
        **kwargs: Any
    ) -> FormatConversation:
        variables: Dict[str, object] = {
            "prompt": prompt,
            "id": id,
            "specification": specification,
            "includeDetails": include_details,
            "correlationId": correlation_id,
        }
        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,
        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,
            "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,
        id: Union[Optional[str], UnsetType] = UNSET,
        specification: Union[Optional[EntityReferenceInput], 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,
        **kwargs: Any
    ) -> PromptConversation:
        variables: Dict[str, object] = {
            "prompt": prompt,
            "id": id,
            "specification": specification,
            "tools": tools,
            "requireTool": require_tool,
            "includeDetails": include_details,
            "correlationId": correlation_id,
        }
        response = await self.execute(
            query=PROMPT_CONVERSATION_GQL,
            operation_name="PromptConversation",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return PromptConversation.model_validate(data)

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

    async def query_conversations(
        self,
        filter: Union[Optional[ConversationFilter], UnsetType] = UNSET,
        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 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 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_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 update_event(self, event: EventUpdateInput, **kwargs: Any) -> UpdateEvent:
        variables: Dict[str, object] = {"event": event}
        response = await self.execute(
            query=UPDATE_EVENT_GQL,
            operation_name="UpdateEvent",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateEvent.model_validate(data)

    async def count_feeds(
        self,
        filter: Union[Optional[FeedFilter], UnsetType] = UNSET,
        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 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_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_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_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 update_feed(self, feed: FeedUpdateInput, **kwargs: Any) -> UpdateFeed:
        variables: Dict[str, object] = {"feed": feed}
        response = await self.execute(
            query=UPDATE_FEED_GQL,
            operation_name="UpdateFeed",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateFeed.model_validate(data)

    async def count_labels(
        self,
        filter: Union[Optional[LabelFilter], UnsetType] = UNSET,
        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 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 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 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 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 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 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 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 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,
        **kwargs: Any
    ) -> CountMedicalStudies:
        variables: Dict[str, object] = {"filter": filter}
        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 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 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 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 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 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 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 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 update_person(
        self, person: PersonUpdateInput, **kwargs: Any
    ) -> UpdatePerson:
        variables: Dict[str, object] = {"person": person}
        response = await self.execute(
            query=UPDATE_PERSON_GQL,
            operation_name="UpdatePerson",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdatePerson.model_validate(data)

    async def count_places(
        self,
        filter: Union[Optional[PlaceFilter], UnsetType] = UNSET,
        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 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 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 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 update_product(
        self, product: ProductUpdateInput, **kwargs: Any
    ) -> UpdateProduct:
        variables: Dict[str, object] = {"product": product}
        response = await self.execute(
            query=UPDATE_PRODUCT_GQL,
            operation_name="UpdateProduct",
            variables=variables,
            **kwargs
        )
        data = self.get_data(response)
        return UpdateProduct.model_validate(data)

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

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

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

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

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

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

    async def count_repos(
        self,
        filter: Union[Optional[RepoFilter], UnsetType] = UNSET,
        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 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_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 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 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_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)