graphlit-client 1.0.20251217001 → 1.0.20251220001

package/dist/client.d.ts

@@ -107,383 +107,2064 @@ declare class Graphlit {
      */
     setRetryConfig(retryConfig: RetryConfig): void;
     private generateToken;
+    /**
+     * Fetch current project.
+     * @returns The project.
+     */
     getProject(): Promise<Types.GetProjectQuery>;
+    /**
+     * Updates a project.
+     * @param project - The project to update.
+     * @returns The updated project.
+     */
     updateProject(project: Types.ProjectUpdateInput): Promise<Types.UpdateProjectMutation>;
+    /**
+     * Lookup usage records given tenant correlation identifier.
+     * @param correlationId - The tenant correlation identifier.
+     * @param startDate - The start date of records to be returned, optional. Defaults to last 30 days.
+     * @param duration - The duration of records to be returned, optional. Defaults to last 30 days.
+     * @returns The project usage records.
+     */
     lookupProjectUsage(correlationId: string, startDate?: Types.Scalars["DateTime"]["input"], duration?: Types.Scalars["TimeSpan"]["input"]): Promise<Types.LookupUsageQuery>;
+    /**
+     * Lookup credit usage given tenant correlation identifier.
+     * @param correlationId - The tenant correlation identifier.
+     * @param startDate - The start date of records to be returned, optional. Defaults to last 30 days.
+     * @param duration - The duration of records to be returned, optional. Defaults to last 30 days.
+     * @returns The project credits.
+     */
     lookupProjectCredits(correlationId: string, startDate?: Types.Scalars["DateTime"]["input"], duration?: Types.Scalars["TimeSpan"]["input"]): Promise<Types.LookupCreditsQuery>;
+    /**
+     * Retrieves project tokens.
+     * @param startDate - The start date of tokens to be returned.
+     * @param duration - The duration of tokens to be returned.
+     * @returns The project tokens.
+     */
     queryProjectTokens(startDate: Types.Scalars["DateTime"]["input"], duration: Types.Scalars["TimeSpan"]["input"]): Promise<Types.QueryTokensQuery>;
+    /**
+     * Retrieves project usage.
+     * @param startDate - The start date of records to be returned.
+     * @param duration - The duration of records to be returned.
+     * @param names - Filter by allowed usage record names, defaults to 'GraphQL'.
+     * @param excludedNames - Filter by excluded usage record names.
+     * @param offset - The offset to the records to be returned, defaults to 0.
+     * @param limit - The number of records to be returned, defaults to 1000.
+     * @returns The project usage records.
+     */
     queryProjectUsage(startDate: Types.Scalars["DateTime"]["input"], duration: Types.Scalars["TimeSpan"]["input"], names?: string[], excludedNames?: string[], offset?: Types.Scalars["Int"]["input"], limit?: Types.Scalars["Int"]["input"]): Promise<Types.QueryUsageQuery>;
+    /**
+     * Retrieves project credits.
+     * @param startDate - The start date of credits to be returned.
+     * @param duration - The duration of credits to be returned.
+     * @returns The project credits.
+     */
     queryProjectCredits(startDate: Types.Scalars["DateTime"]["input"], duration: Types.Scalars["TimeSpan"]["input"]): Promise<Types.QueryCreditsQuery>;
+    /**
+     * Sends a notification.
+     * @param connector - The integration connector used to send the notification.
+     * @param text - The notification text.
+     * @param textType - The text type, optional.
+     * @returns The result of the notification.
+     */
     sendNotification(connector: Types.IntegrationConnectorInput, text: string, textType?: Types.TextTypes): Promise<Types.SendNotificationMutation>;
+    /**
+     * Enumerates the web pages at or beneath the provided URL using web sitemap.
+     * @param uri - The URI of the web page to be mapped.
+     * @param allowedPaths - The list of regular expressions for URL paths to be crawled, i.e. "^\/public\/blogs\/.*".
+     * @param excludedPaths - The list of regular expressions for URL paths to not be crawled, i.e. "^\/internal\/private\/.*".
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The mapped URIs.
+     */
     mapWeb(uri: string, allowedPaths?: string[], excludedPaths?: string[], correlationId?: string): Promise<Types.MapWebQuery>;
+    /**
+     * Searches the web based on the provided properties.
+     * @param text - The web search text.
+     * @param service - The web search service type, defaults to Tavily.
+     * @param limit - The number of web search results to be returned, defaults to 10.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The web search results.
+     */
     searchWeb(text: string, service?: Types.SearchServiceTypes, limit?: number, correlationId?: string): Promise<Types.SearchWebQuery>;
+    /**
+     * Creates an alert.
+     * @param alert - The alert to create.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The created alert.
+     */
     createAlert(alert: Types.AlertInput, correlationId?: string): Promise<Types.CreateAlertMutation>;
+    /**
+     * Updates an alert.
+     * @param alert - The alert to update.
+     * @returns The updated alert.
+     */
     updateAlert(alert: Types.AlertUpdateInput): Promise<Types.UpdateAlertMutation>;
+    /**
+     * Creates or updates an alert.
+     * @param alert - The alert to create or update.
+     * @returns The created or updated alert.
+     */
     upsertAlert(alert: Types.AlertInput): Promise<Types.UpsertAlertMutation>;
+    /**
+     * Deletes an alert.
+     * @param id - The ID of the alert to delete.
+     * @returns The deleted alert.
+     */
     deleteAlert(id: string): Promise<Types.DeleteAlertMutation>;
+    /**
+     * Deletes multiple alerts.
+     * @param ids - The IDs of the alerts to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted alerts.
+     */
     deleteAlerts(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteAlertsMutation>;
+    /**
+     * Deletes all alerts based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting alerts.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllAlerts(filter?: Types.AlertFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllAlertsMutation>;
+    /**
+     * Enables an alert.
+     * @param id - The ID of the alert to enable.
+     * @returns The enabled alert.
+     */
     enableAlert(id: string): Promise<Types.EnableAlertMutation>;
+    /**
+     * Disables an alert.
+     * @param id - The ID of the alert to disable.
+     * @returns The disabled alert.
+     */
     disableAlert(id: string): Promise<Types.DisableAlertMutation>;
+    /**
+     * Lookup an alert given its ID.
+     * @param id - ID of the alert.
+     * @returns The alert.
+     */
     getAlert(id: string): Promise<Types.GetAlertQuery>;
+    /**
+     * Retrieves alerts based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving alerts.
+     * @returns The alerts.
+     */
     queryAlerts(filter?: Types.AlertFilter): Promise<Types.QueryAlertsQuery>;
+    /**
+     * Counts alerts based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting alerts.
+     * @returns The count of alerts.
+     */
     countAlerts(filter?: Types.AlertFilter): Promise<Types.CountAlertsQuery>;
+    /**
+     * Creates a collection.
+     * @param collection - The collection to create.
+     * @returns The created collection.
+     */
     createCollection(collection: Types.CollectionInput): Promise<Types.CreateCollectionMutation>;
+    /**
+     * Updates a collection.
+     * @param collection - The collection to update.
+     * @returns The updated collection.
+     */
     updateCollection(collection: Types.CollectionUpdateInput): Promise<Types.UpdateCollectionMutation>;
+    /**
+     * Deletes a collection.
+     * @param id - The ID of the collection to delete.
+     * @returns The deleted collection.
+     */
     deleteCollection(id: string): Promise<Types.DeleteCollectionMutation>;
+    /**
+     * Deletes multiple collections.
+     * @param ids - The IDs of the collections to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted collections.
+     */
     deleteCollections(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteCollectionsMutation>;
+    /**
+     * Deletes all collections based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting collections.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllCollections(filter?: Types.CollectionFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllCollectionsMutation>;
+    /**
+     * Adds contents to collections.
+     * @param contents - The contents to add.
+     * @param collections - The collections to add the contents to.
+     * @returns The result of the operation.
+     */
     addContentsToCollections(contents: Types.EntityReferenceInput[], collections: Types.EntityReferenceInput[]): Promise<Types.AddContentsToCollectionsMutation>;
+    /**
+     * Removes contents from a collection.
+     * @param contents - The contents to remove.
+     * @param collection - The collection to remove the contents from.
+     * @returns The result of the operation.
+     */
     removeContentsFromCollection(contents: Types.EntityReferenceInput[], collection: Types.EntityReferenceInput): Promise<Types.RemoveContentsFromCollectionMutation>;
+    /**
+     * Lookup a collection given its ID.
+     * @param id - ID of the collection.
+     * @returns The collection.
+     */
     getCollection(id: string): Promise<Types.GetCollectionQuery>;
+    /**
+     * Retrieves collections based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving collections.
+     * @returns The collections.
+     */
     queryCollections(filter?: Types.CollectionFilter): Promise<Types.QueryCollectionsQuery>;
+    /**
+     * Counts collections based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting collections.
+     * @returns The count of collections.
+     */
     countCollections(filter?: Types.CollectionFilter): Promise<Types.CountCollectionsQuery>;
+    /**
+     * Describes an image using a multimodal LLM.
+     * @param prompt - The prompt to use for describing the image.
+     * @param uri - The URI of the image to describe.
+     * @param specification - The LLM specification to use, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The image description.
+     */
     describeImage(prompt: string, uri: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.DescribeImageMutation>;
+    /**
+     * Describes a base64-encoded image using a multimodal LLM.
+     * @param prompt - The prompt to use for describing the image.
+     * @param mimeType - The MIME type of the image.
+     * @param data - The base64-encoded image data.
+     * @param specification - The LLM specification to use, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The image description.
+     */
     describeEncodedImage(prompt: string, mimeType: string, data: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.DescribeEncodedImageMutation>;
+    /**
+     * Takes a screenshot of a web page.
+     * @param uri - The URI of the web page to screenshot.
+     * @param maximumHeight - The maximum height of the screenshot, optional.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param workflow - The workflow to use for processing, optional.
+     * @param collections - The collections to add the content to, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The screenshot content.
+     */
     screenshotPage(uri: string, maximumHeight?: number, isSynchronous?: boolean, workflow?: Types.EntityReferenceInput, collections?: Types.EntityReferenceInput[], correlationId?: string): Promise<Types.ScreenshotPageMutation>;
+    /**
+     * Ingests a batch of text contents.
+     * @param batch - The batch of text contents to ingest.
+     * @param textType - The type of text (plain, markdown, HTML).
+     * @param collections - The collections to add the contents to, optional.
+     * @param observations - The observations to assign to the contents, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The ingested contents.
+     */
     ingestTextBatch(batch: Types.TextContentInput[], textType: Types.TextTypes, collections?: Types.EntityReferenceInput[], observations?: Types.ObservationReferenceInput[], correlationId?: string): Promise<Types.IngestTextBatchMutation>;
+    /**
+     * Ingests a batch of URIs.
+     * @param uris - The URIs to ingest.
+     * @param workflow - The workflow to use for processing, optional.
+     * @param collections - The collections to add the contents to, optional.
+     * @param observations - The observations to assign to the contents, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The ingested contents.
+     */
     ingestBatch(uris: string[], workflow?: Types.EntityReferenceInput, collections?: Types.EntityReferenceInput[], observations?: Types.ObservationReferenceInput[], correlationId?: string): Promise<Types.IngestBatchMutation>;
+    /**
+     * Ingests content from a URI.
+     * @param uri - The URI of the content to ingest.
+     * @param name - The name of the content, optional.
+     * @param id - The ID to assign to the content, optional.
+     * @param identifier - The external identifier for the content, optional.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param workflow - The workflow to use for processing, optional.
+     * @param collections - The collections to add the content to, optional.
+     * @param observations - The observations to assign to the content, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The ingested content.
+     */
     ingestUri(uri: string, name?: string, id?: string, identifier?: string, isSynchronous?: boolean, workflow?: Types.EntityReferenceInput, collections?: Types.EntityReferenceInput[], observations?: Types.ObservationReferenceInput[], correlationId?: string): Promise<Types.IngestUriMutation>;
+    /**
+     * Ingests text content.
+     * @param text - The text to ingest.
+     * @param name - The name of the content, optional.
+     * @param textType - The type of text (plain, markdown, HTML), optional.
+     * @param uri - The URI associated with the content, optional.
+     * @param id - The ID to assign to the content, optional.
+     * @param identifier - The external identifier for the content, optional.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param workflow - The workflow to use for processing, optional.
+     * @param collections - The collections to add the content to, optional.
+     * @param observations - The observations to assign to the content, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The ingested content.
+     */
     ingestText(text: string, name?: string, textType?: Types.TextTypes, uri?: string, id?: string, identifier?: string, isSynchronous?: boolean, workflow?: Types.EntityReferenceInput, collections?: Types.EntityReferenceInput[], observations?: Types.ObservationReferenceInput[], correlationId?: string): Promise<Types.IngestTextMutation>;
+    /**
+     * Ingests a memory (ephemeral text content).
+     * @param text - The text to ingest as memory.
+     * @param name - The name of the memory, optional.
+     * @param textType - The type of text (plain, markdown, HTML), optional.
+     * @param id - The ID to assign to the memory, optional.
+     * @param identifier - The external identifier for the memory, optional.
+     * @param collections - The collections to add the memory to, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The ingested memory.
+     */
     ingestMemory(text: string, name?: string, textType?: Types.TextTypes, id?: string, identifier?: string, collections?: Types.EntityReferenceInput[], correlationId?: string): Promise<Types.IngestMemoryMutation>;
+    /**
+     * Ingests an event.
+     * @param markdown - The markdown content of the event.
+     * @param name - The name of the event, optional.
+     * @param description - The description of the event, optional.
+     * @param eventDate - The date of the event, optional.
+     * @param id - The ID to assign to the event, optional.
+     * @param identifier - The external identifier for the event, optional.
+     * @param collections - The collections to add the event to, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The ingested event.
+     */
     ingestEvent(markdown: string, name?: string, description?: string, eventDate?: Types.Scalars["DateTime"]["input"], id?: string, identifier?: string, collections?: Types.EntityReferenceInput[], correlationId?: string): Promise<Types.IngestEventMutation>;
+    /**
+     * Ingests a base64-encoded file.
+     * @param name - The name of the file.
+     * @param data - The base64-encoded file data.
+     * @param mimeType - The MIME type of the file.
+     * @param fileCreationDate - The file creation date, optional.
+     * @param fileModifiedDate - The file modified date, optional.
+     * @param id - The ID to assign to the content, optional.
+     * @param identifier - The external identifier for the content, optional.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param workflow - The workflow to use for processing, optional.
+     * @param collections - The collections to add the content to, optional.
+     * @param observations - The observations to assign to the content, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The ingested content.
+     */
     ingestEncodedFile(name: string, data: string, mimeType: string, fileCreationDate?: Types.Scalars["DateTime"]["input"], fileModifiedDate?: Types.Scalars["DateTime"]["input"], id?: string, identifier?: string, isSynchronous?: boolean, workflow?: Types.EntityReferenceInput, collections?: Types.EntityReferenceInput[], observations?: Types.ObservationReferenceInput[], correlationId?: string): Promise<Types.IngestEncodedFileMutation>;
+    /**
+     * Updates content.
+     * @param content - The content to update.
+     * @returns The updated content.
+     */
     updateContent(content: Types.ContentUpdateInput): Promise<Types.UpdateContentMutation>;
+    /**
+     * Deletes content.
+     * @param id - The ID of the content to delete.
+     * @returns The deleted content.
+     */
     deleteContent(id: string): Promise<Types.DeleteContentMutation>;
+    /**
+     * Deletes multiple contents.
+     * @param ids - The IDs of the contents to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted contents.
+     */
     deleteContents(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteContentsMutation>;
+    /**
+     * Deletes all contents based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting contents.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllContents(filter?: Types.ContentFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllContentsMutation>;
+    /**
+     * Summarizes text using the specified summarization strategy.
+     * @param summarization - The summarization strategy to use.
+     * @param text - The text to summarize.
+     * @param textType - The type of text (plain, markdown, HTML), optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The summarized text.
+     */
     summarizeText(summarization: Types.SummarizationStrategyInput, text: string, textType?: Types.TextTypes, correlationId?: string): Promise<Types.SummarizeTextMutation>;
+    /**
+     * Summarizes contents using the specified summarization strategies.
+     * @param summarizations - The summarization strategies to use.
+     * @param filter - The filter criteria to apply when retrieving contents to summarize.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The summarized contents.
+     */
     summarizeContents(summarizations: Types.SummarizationStrategyInput[], filter?: Types.ContentFilter, correlationId?: string): Promise<Types.SummarizeContentsMutation>;
+    /**
+     * Extracts structured data from text using tool definitions.
+     * @param prompt - The prompt to guide extraction.
+     * @param text - The text to extract from.
+     * @param tools - The tool definitions for extraction.
+     * @param specification - The LLM specification to use, optional.
+     * @param textType - The type of text (plain, markdown, HTML), optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The extracted data.
+     */
     extractText(prompt: string, text: string, tools: Types.ToolDefinitionInput[], specification?: Types.EntityReferenceInput, textType?: Types.TextTypes, correlationId?: string): Promise<Types.ExtractTextMutation>;
+    /**
+     * Extracts structured data from contents using tool definitions.
+     * @param prompt - The prompt to guide extraction.
+     * @param tools - The tool definitions for extraction.
+     * @param specification - The LLM specification to use, optional.
+     * @param filter - The filter criteria to apply when retrieving contents.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The extracted data.
+     */
     extractContents(prompt: string, tools: Types.ToolDefinitionInput[], specification?: Types.EntityReferenceInput, filter?: Types.ContentFilter, correlationId?: string): Promise<Types.ExtractContentsMutation>;
+    /**
+     * Extracts observables (entities) from text.
+     * @param text - The text to extract observables from.
+     * @param textType - The type of text (plain, markdown, HTML), optional.
+     * @param specification - The LLM specification to use, optional.
+     * @param observableTypes - The types of observables to extract, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The extracted observables.
+     */
     extractObservables(text: string, textType?: Types.TextTypes, specification?: Types.EntityReferenceInput, observableTypes?: Types.ObservableTypes[], correlationId?: string): Promise<Types.ExtractObservablesMutation>;
+    /**
+     * Publishes contents to an external connector.
+     * @param publishPrompt - The prompt for publishing.
+     * @param connector - The publishing connector to use.
+     * @param summaryPrompt - The prompt for summarizing each content, optional.
+     * @param summarySpecification - The LLM specification for summarization, optional.
+     * @param publishSpecification - The LLM specification for publishing, optional.
+     * @param name - The name of the published content, optional.
+     * @param filter - The filter criteria for selecting contents, optional.
+     * @param workflow - The workflow to use, optional.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param includeDetails - Whether to include details in publishing, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The published content.
+     */
     publishContents(publishPrompt: string, connector: Types.ContentPublishingConnectorInput, summaryPrompt?: string, summarySpecification?: Types.EntityReferenceInput, publishSpecification?: Types.EntityReferenceInput, name?: string, filter?: Types.ContentFilter, workflow?: Types.EntityReferenceInput, isSynchronous?: boolean, includeDetails?: boolean, correlationId?: string): Promise<Types.PublishContentsMutation>;
+    /**
+     * Publishes text to an external connector.
+     * @param text - The text to publish.
+     * @param textType - The type of text (plain, markdown, HTML).
+     * @param connector - The publishing connector to use.
+     * @param name - The name of the published content, optional.
+     * @param workflow - The workflow to use, optional.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The published content.
+     */
     publishText(text: string, textType: Types.TextTypes, connector: Types.ContentPublishingConnectorInput, name?: string, workflow?: Types.EntityReferenceInput, isSynchronous?: boolean, correlationId?: string): Promise<Types.PublishTextMutation>;
+    /**
+     * Researches contents and publishes the results.
+     * @param connector - The publishing connector to use.
+     * @param filter - The filter criteria for selecting contents, optional.
+     * @param name - The name of the research output, optional.
+     * @param summarySpecification - The LLM specification for summarization, optional.
+     * @param publishSpecification - The LLM specification for publishing, optional.
+     * @param workflow - The workflow to use, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The research results.
+     */
     researchContents(connector: Types.ContentPublishingConnectorInput, filter?: Types.ContentFilter, name?: string, summarySpecification?: Types.EntityReferenceInput, publishSpecification?: Types.EntityReferenceInput, workflow?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.ResearchContentsMutation>;
+    /**
+     * Lookup content given its ID.
+     * @param id - ID of the content.
+     * @returns The content.
+     */
     getContent(id: string): Promise<Types.GetContentQuery>;
+    /**
+     * Lookup multiple contents given their IDs.
+     * @param ids - IDs of the contents.
+     * @returns The contents.
+     */
     lookupContents(ids: string[]): Promise<Types.LookupContentsQuery>;
+    /**
+     * Retrieves observables based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving observables.
+     * @returns The observables.
+     */
     queryObservables(filter?: Types.ContentFilter): Promise<Types.QueryObservablesQuery>;
+    /**
+     * Retrieves contents based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving contents.
+     * @returns The contents.
+     */
     queryContents(filter?: Types.ContentFilter): Promise<Types.QueryContentsQuery>;
+    /**
+     * Retrieves contents with their observations based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving contents.
+     * @returns The contents with observations.
+     */
     queryContentsObservations(filter?: Types.ContentFilter): Promise<Types.QueryContentsObservationsQuery>;
+    /**
+     * Retrieves content facets based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving facets.
+     * @returns The content facets.
+     */
     queryContentsFacets(filter?: Types.ContentFilter): Promise<Types.QueryContentsFacetsQuery>;
+    /**
+     * Retrieves the content knowledge graph based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving the graph.
+     * @returns The content knowledge graph.
+     */
     queryContentsGraph(filter?: Types.ContentFilter): Promise<Types.QueryContentsGraphQuery>;
+    /**
+     * Retrieves the knowledge graph based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving the graph.
+     * @param graph - The graph configuration, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The knowledge graph.
+     */
     queryGraph(filter?: Types.GraphFilter, graph?: Types.GraphInput, correlationId?: string): Promise<Types.QueryGraphQuery>;
+    /**
+     * Lookup an entity and its relationships.
+     * @param filter - The filter criteria for entity relationships.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The entity with relationships.
+     */
     lookupEntity(filter: Types.EntityRelationshipsFilter, correlationId?: string): Promise<Types.LookupEntityQuery>;
+    /**
+     * Counts contents based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting contents.
+     * @returns The count of contents.
+     */
     countContents(filter?: Types.ContentFilter): Promise<Types.CountContentsQuery>;
+    /**
+     * Checks if content processing is complete.
+     * @param id - ID of the content.
+     * @returns Whether the content is done processing.
+     */
     isContentDone(id: string): Promise<Types.IsContentDoneQuery>;
+    /**
+     * Creates a conversation.
+     * @param conversation - The conversation to create.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The created conversation.
+     */
     createConversation(conversation: Types.ConversationInput, correlationId?: string): Promise<Types.CreateConversationMutation>;
+    /**
+     * Updates a conversation.
+     * @param conversation - The conversation to update.
+     * @returns The updated conversation.
+     */
     updateConversation(conversation: Types.ConversationUpdateInput): Promise<Types.UpdateConversationMutation>;
+    /**
+     * Deletes a conversation.
+     * @param id - The ID of the conversation to delete.
+     * @returns The deleted conversation.
+     */
     deleteConversation(id: string): Promise<Types.DeleteConversationMutation>;
+    /**
+     * Deletes multiple conversations.
+     * @param ids - The IDs of the conversations to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted conversations.
+     */
     deleteConversations(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteConversationsMutation>;
+    /**
+     * Deletes all conversations based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting conversations.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllConversations(filter?: Types.ConversationFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllConversationsMutation>;
+    /**
+     * Clears all messages from a conversation.
+     * @param id - The ID of the conversation to clear.
+     * @returns The cleared conversation.
+     */
     clearConversation(id: string): Promise<Types.ClearConversationMutation>;
+    /**
+     * Closes a conversation.
+     * @param id - The ID of the conversation to close.
+     * @returns The closed conversation.
+     */
     closeConversation(id: string): Promise<Types.CloseConversationMutation>;
+    /**
+     * Lookup a conversation given its ID.
+     * @param id - ID of the conversation.
+     * @returns The conversation.
+     */
     getConversation(id: string): Promise<Types.GetConversationQuery>;
+    /**
+     * Retrieves conversations based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving conversations.
+     * @returns The conversations.
+     */
     queryConversations(filter?: Types.ConversationFilter): Promise<Types.QueryConversationsQuery>;
+    /**
+     * Counts conversations based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting conversations.
+     * @returns The count of conversations.
+     */
     countConversations(filter?: Types.ConversationFilter): Promise<Types.CountConversationsQuery>;
+    /**
+     * Revises an image in an existing conversation using a multimodal LLM.
+     * @param prompt - The prompt to use for revision.
+     * @param uri - The URI of the image to revise.
+     * @param id - The conversation ID, optional.
+     * @param specification - The LLM specification to use, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The revised conversation message.
+     */
     reviseImage(prompt: string, uri: string, id?: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.ReviseImageMutation>;
+    /**
+     * Revises a base64-encoded image in an existing conversation using a multimodal LLM.
+     * @param prompt - The prompt to use for revision.
+     * @param mimeType - The MIME type of the image.
+     * @param data - The base64-encoded image data.
+     * @param id - The conversation ID, optional.
+     * @param specification - The LLM specification to use, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The revised conversation message.
+     */
     reviseEncodedImage(prompt: string, mimeType: string, data: string, id?: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.ReviseEncodedImageMutation>;
+    /**
+     * Revises text in an existing conversation.
+     * @param prompt - The prompt to use for revision.
+     * @param text - The text to revise.
+     * @param id - The conversation ID, optional.
+     * @param specification - The LLM specification to use, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The revised conversation message.
+     */
     reviseText(prompt: string, text: string, id?: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.ReviseTextMutation>;
+    /**
+     * Revises content in an existing conversation.
+     * @param prompt - The prompt to use for revision.
+     * @param content - The content to revise.
+     * @param id - The conversation ID, optional.
+     * @param specification - The LLM specification to use, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The revised conversation message.
+     */
     reviseContent(prompt: string, content: Types.EntityReferenceInput, id?: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.ReviseContentMutation>;
+    /**
+     * Prompts an LLM without a conversation context.
+     * @param prompt - The prompt text, optional.
+     * @param mimeType - The MIME type for multimodal input, optional.
+     * @param data - The base64-encoded data for multimodal input, optional.
+     * @param specification - The LLM specification to use, optional.
+     * @param messages - Previous messages for context, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The LLM response.
+     */
     prompt(prompt?: string, mimeType?: string, data?: string, specification?: Types.EntityReferenceInput, messages?: Types.ConversationMessageInput[], correlationId?: string): Promise<Types.PromptMutation>;
+    /**
+     * Retrieves relevant sources from a view for RAG.
+     * @param prompt - The prompt to use for retrieval.
+     * @param id - The view ID.
+     * @param retrievalStrategy - The retrieval strategy, optional.
+     * @param rerankingStrategy - The reranking strategy, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The retrieved sources.
+     */
     retrieveView(prompt: string, id: string, retrievalStrategy?: Types.RetrievalStrategyInput, rerankingStrategy?: Types.RerankingStrategyInput, correlationId?: string): Promise<Types.RetrieveViewMutation>;
+    /**
+     * Retrieves relevant sources for RAG.
+     * @param prompt - The prompt to use for retrieval.
+     * @param filter - The filter criteria for selecting contents, optional.
+     * @param augmentedFilter - Additional filter for augmented retrieval, optional.
+     * @param retrievalStrategy - The retrieval strategy, optional.
+     * @param rerankingStrategy - The reranking strategy, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The retrieved sources.
+     */
     retrieveSources(prompt: string, filter?: Types.ContentFilter, augmentedFilter?: Types.ContentFilter, retrievalStrategy?: Types.RetrievalStrategyInput, rerankingStrategy?: Types.RerankingStrategyInput, correlationId?: string): Promise<Types.RetrieveSourcesMutation>;
+    /**
+     * Formats a conversation for external LLM completion.
+     * @param prompt - The prompt to format.
+     * @param id - The conversation ID, optional.
+     * @param specification - The LLM specification to use, optional.
+     * @param tools - Tool definitions for function calling, optional.
+     * @param systemPrompt - The system prompt, optional.
+     * @param includeDetails - Whether to include details, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The formatted conversation.
+     */
     formatConversation(prompt: string, id?: string, specification?: Types.EntityReferenceInput, tools?: Types.ToolDefinitionInput[], systemPrompt?: string, includeDetails?: boolean, correlationId?: string): Promise<Types.FormatConversationMutation>;
+    /**
+     * Completes a conversation with an external LLM response.
+     * @param completion - The completion text from the external LLM.
+     * @param id - The conversation ID.
+     * @param completionTime - The time taken for completion, optional.
+     * @param ttft - Time to first token, optional.
+     * @param throughput - Tokens per second throughput, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The completed conversation.
+     */
     completeConversation(completion: string, id: string, completionTime?: Types.Scalars["TimeSpan"]["input"], ttft?: Types.Scalars["TimeSpan"]["input"], throughput?: Types.Scalars["Float"]["input"], correlationId?: string): Promise<Types.CompleteConversationMutation>;
+    /**
+     * Asks a question about Graphlit SDK usage.
+     * @param prompt - The question about Graphlit.
+     * @param type - The SDK type (Node.js, Python, .NET), optional.
+     * @param id - The conversation ID, optional.
+     * @param specification - The LLM specification to use, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The Graphlit answer.
+     */
     askGraphlit(prompt: string, type?: Types.SdkTypes, id?: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.AskGraphlitMutation>;
+    /**
+     * Creates a branch of an existing conversation.
+     * @param id - The conversation ID to branch from.
+     * @returns The branched conversation.
+     */
     branchConversation(id: string): Promise<Types.BranchConversationMutation>;
+    /**
+     * Prompts a conversation with an LLM.
+     * @param prompt - The prompt text.
+     * @param id - The conversation ID, optional. If not provided, creates a new conversation.
+     * @param specification - The LLM specification to use, optional.
+     * @param mimeType - The MIME type for multimodal input, optional.
+     * @param data - The base64-encoded data for multimodal input, optional.
+     * @param tools - Tool definitions for function calling, optional.
+     * @param requireTool - Whether to require a tool call, optional.
+     * @param systemPrompt - The system prompt, optional.
+     * @param includeDetails - Whether to include details, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The conversation response.
+     */
     promptConversation(prompt: string, id?: string, specification?: Types.EntityReferenceInput, mimeType?: string, data?: string, tools?: Types.ToolDefinitionInput[], requireTool?: boolean, systemPrompt?: string, includeDetails?: boolean, correlationId?: string): Promise<Types.PromptConversationMutation>;
+    /**
+     * Continues a conversation with tool responses.
+     * @param id - The conversation ID.
+     * @param responses - The tool call responses.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The continued conversation.
+     */
     continueConversation(id: string, responses: Types.ConversationToolResponseInput[], correlationId?: string): Promise<Types.ContinueConversationMutation>;
+    /**
+     * Publishes a conversation to an external connector.
+     * @param id - The conversation ID.
+     * @param connector - The publishing connector to use.
+     * @param name - The name of the published conversation, optional.
+     * @param workflow - The workflow to use, optional.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The published conversation.
+     */
     publishConversation(id: string, connector: Types.ContentPublishingConnectorInput, name?: string, workflow?: Types.EntityReferenceInput, isSynchronous?: boolean, correlationId?: string): Promise<Types.PublishConversationMutation>;
+    /**
+     * Suggests follow-up prompts for a conversation.
+     * @param id - The conversation ID.
+     * @param count - The number of suggestions to generate, optional.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The suggested prompts.
+     */
     suggestConversation(id: string, count?: number, correlationId?: string): Promise<Types.SuggestConversationMutation>;
+    /**
+     * Queries Microsoft calendars.
+     * @param properties - The Microsoft calendar query properties.
+     * @returns The Microsoft calendars.
+     */
     queryMicrosoftCalendars(properties: Types.MicrosoftCalendarsInput): Promise<Types.QueryMicrosoftCalendarsQuery>;
+    /**
+     * Queries Google calendars.
+     * @param properties - The Google calendar query properties.
+     * @returns The Google calendars.
+     */
     queryGoogleCalendars(properties: Types.GoogleCalendarsInput): Promise<Types.QueryGoogleCalendarsQuery>;
+    /**
+     * Queries Box folders.
+     * @param properties - The Box folder query properties.
+     * @param folderId - The parent folder ID, optional.
+     * @returns The Box folders.
+     */
     queryBoxFolders(properties: Types.BoxFoldersInput, folderId?: string): Promise<Types.QueryBoxFoldersQuery>;
+    /**
+     * Queries Dropbox folders.
+     * @param properties - The Dropbox folder query properties.
+     * @param folderPath - The folder path, optional.
+     * @returns The Dropbox folders.
+     */
     queryDropboxFolders(properties: Types.DropboxFoldersInput, folderPath?: string): Promise<Types.QueryDropboxFoldersQuery>;
+    /**
+     * Queries Google Drive folders.
+     * @param properties - The Google Drive folder query properties.
+     * @param folderId - The parent folder ID, optional.
+     * @returns The Google Drive folders.
+     */
     queryGoogleDriveFolders(properties: Types.GoogleDriveFoldersInput, folderId?: string): Promise<Types.QueryGoogleDriveFoldersQuery>;
+    /**
+     * Queries OneDrive folders.
+     * @param properties - The OneDrive folder query properties.
+     * @param folderId - The parent folder ID, optional.
+     * @returns The OneDrive folders.
+     */
     queryOneDriveFolders(properties: Types.OneDriveFoldersInput, folderId?: string): Promise<Types.QueryOneDriveFoldersQuery>;
+    /**
+     * Queries SharePoint folders.
+     * @param properties - The SharePoint folder query properties.
+     * @param libraryId - The library ID.
+     * @param folderId - The parent folder ID, optional.
+     * @returns The SharePoint folders.
+     */
     querySharePointFolders(properties: Types.SharePointFoldersInput, libraryId: string, folderId?: string): Promise<Types.QuerySharePointFoldersQuery>;
+    /**
+     * Queries SharePoint libraries.
+     * @param properties - The SharePoint library query properties.
+     * @returns The SharePoint libraries.
+     */
     querySharePointLibraries(properties: Types.SharePointLibrariesInput): Promise<Types.QuerySharePointLibrariesQuery>;
+    /**
+     * Queries Microsoft Teams teams.
+     * @param properties - The Microsoft Teams query properties.
+     * @returns The Microsoft Teams teams.
+     */
     queryMicrosoftTeamsTeams(properties: Types.MicrosoftTeamsTeamsInput): Promise<Types.QueryMicrosoftTeamsTeamsQuery>;
+    /**
+     * Queries Microsoft Teams channels.
+     * @param properties - The Microsoft Teams channel query properties.
+     * @param teamId - The team ID.
+     * @returns The Microsoft Teams channels.
+     */
     queryMicrosoftTeamsChannels(properties: Types.MicrosoftTeamsChannelsInput, teamId: string): Promise<Types.QueryMicrosoftTeamsChannelsQuery>;
+    /**
+     * Queries Discord guilds (servers).
+     * @param properties - The Discord guild query properties.
+     * @returns The Discord guilds.
+     */
     queryDiscordGuilds(properties: Types.DiscordGuildsInput): Promise<Types.QueryDiscordGuildsQuery>;
+    /**
+     * Queries Discord channels.
+     * @param properties - The Discord channel query properties.
+     * @returns The Discord channels.
+     */
     queryDiscordChannels(properties: Types.DiscordChannelsInput): Promise<Types.QueryDiscordChannelsQuery>;
+    /**
+     * Queries Slack channels.
+     * @param properties - The Slack channel query properties.
+     * @returns The Slack channels.
+     */
     querySlackChannels(properties: Types.SlackChannelsInput): Promise<Types.QuerySlackChannelsQuery>;
+    /**
+     * Queries Linear projects.
+     * @param properties - The Linear project query properties.
+     * @returns The Linear projects.
+     */
     queryLinearProjects(properties: Types.LinearProjectsInput): Promise<Types.QueryLinearProjectsQuery>;
+    /**
+     * Queries GitHub repositories.
+     * @param properties - The GitHub repository query properties.
+     * @param sortBy - The sort order, optional.
+     * @returns The GitHub repositories.
+     */
     queryGitHubRepositories(properties: Types.GitHubRepositoriesInput, sortBy?: Types.GitHubRepositorySortTypes): Promise<Types.QueryGitHubRepositoriesQuery>;
+    /**
+     * Queries Notion databases.
+     * @param properties - The Notion database query properties.
+     * @returns The Notion databases.
+     */
     queryNotionDatabases(properties: Types.NotionDatabasesInput): Promise<Types.QueryNotionDatabasesQuery>;
+    /**
+     * Queries Notion pages.
+     * @param properties - The Notion page query properties.
+     * @param identifier - The Notion database or page identifier.
+     * @returns The Notion pages.
+     */
     queryNotionPages(properties: Types.NotionPagesInput, identifier: string): Promise<Types.QueryNotionPagesQuery>;
+    /**
+     * Creates a feed.
+     * @param feed - The feed to create.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The created feed.
+     */
     createFeed(feed: Types.FeedInput, correlationId?: string): Promise<Types.CreateFeedMutation>;
+    /**
+     * Updates a feed.
+     * @param feed - The feed to update.
+     * @returns The updated feed.
+     */
     updateFeed(feed: Types.FeedUpdateInput): Promise<Types.UpdateFeedMutation>;
+    /**
+     * Deletes a feed.
+     * @param id - The ID of the feed to delete.
+     * @returns The deleted feed.
+     */
     deleteFeed(id: string): Promise<Types.DeleteFeedMutation>;
+    /**
+     * Deletes multiple feeds.
+     * @param ids - The IDs of the feeds to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted feeds.
+     */
     deleteFeeds(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteFeedsMutation>;
+    /**
+     * Deletes all feeds based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting feeds.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllFeeds(filter?: Types.FeedFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllFeedsMutation>;
+    /**
+     * Triggers a feed to run immediately.
+     * @param id - The ID of the feed to trigger.
+     * @returns The triggered feed.
+     */
     triggerFeed(id: string): Promise<Types.TriggerFeedMutation>;
+    /**
+     * Enables a feed.
+     * @param id - The ID of the feed to enable.
+     * @returns The enabled feed.
+     */
     enableFeed(id: string): Promise<Types.EnableFeedMutation>;
+    /**
+     * Disables a feed.
+     * @param id - The ID of the feed to disable.
+     * @returns The disabled feed.
+     */
     disableFeed(id: string): Promise<Types.DisableFeedMutation>;
+    /**
+     * Lookup a feed given its ID.
+     * @param id - ID of the feed.
+     * @returns The feed.
+     */
     getFeed(id: string): Promise<Types.GetFeedQuery>;
+    /**
+     * Retrieves feeds based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving feeds.
+     * @returns The feeds.
+     */
     queryFeeds(filter?: Types.FeedFilter): Promise<Types.QueryFeedsQuery>;
+    /**
+     * Counts feeds based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting feeds.
+     * @returns The count of feeds.
+     */
     countFeeds(filter?: Types.FeedFilter): Promise<Types.CountFeedsQuery>;
+    /**
+     * Checks if a feed exists based on the provided filter criteria.
+     * @param filter - The filter criteria to apply.
+     * @returns Whether the feed exists.
+     */
     feedExists(filter?: Types.FeedFilter): Promise<Types.FeedExistsQuery>;
+    /**
+     * Checks if feed processing is complete.
+     * @param id - ID of the feed.
+     * @returns Whether the feed is done processing.
+     */
     isFeedDone(id: string): Promise<Types.IsFeedDoneQuery>;
+    /**
+     * Prompts multiple specifications and returns the best response.
+     * @param prompt - The prompt to send to each specification.
+     * @param ids - The IDs of the specifications to prompt.
+     * @returns The best response.
+     */
     promptSpecifications(prompt: string, ids: string[]): Promise<Types.PromptSpecificationsMutation>;
+    /**
+     * Creates a specification (LLM configuration).
+     * @param specification - The specification to create.
+     * @returns The created specification.
+     */
     createSpecification(specification: Types.SpecificationInput): Promise<Types.CreateSpecificationMutation>;
+    /**
+     * Updates a specification.
+     * @param specification - The specification to update.
+     * @returns The updated specification.
+     */
     updateSpecification(specification: Types.SpecificationUpdateInput): Promise<Types.UpdateSpecificationMutation>;
+    /**
+     * Creates or updates a specification.
+     * @param specification - The specification to create or update.
+     * @returns The created or updated specification.
+     */
     upsertSpecification(specification: Types.SpecificationInput): Promise<Types.UpsertSpecificationMutation>;
+    /**
+     * Deletes a specification.
+     * @param id - The ID of the specification to delete.
+     * @returns The deleted specification.
+     */
     deleteSpecification(id: string): Promise<Types.DeleteSpecificationMutation>;
+    /**
+     * Deletes multiple specifications.
+     * @param ids - The IDs of the specifications to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted specifications.
+     */
     deleteSpecifications(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteSpecificationsMutation>;
+    /**
+     * Deletes all specifications based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting specifications.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllSpecifications(filter?: Types.SpecificationFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllSpecificationsMutation>;
+    /**
+     * Lookup a specification given its ID.
+     * @param id - ID of the specification.
+     * @returns The specification.
+     */
     getSpecification(id: string): Promise<Types.GetSpecificationQuery>;
+    /**
+     * Retrieves specifications based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving specifications.
+     * @returns The specifications.
+     */
     querySpecifications(filter?: Types.SpecificationFilter): Promise<Types.QuerySpecificationsQuery>;
+    /**
+     * Counts specifications based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting specifications.
+     * @returns The count of specifications.
+     */
     countSpecifications(filter?: Types.SpecificationFilter): Promise<Types.CountSpecificationsQuery>;
+    /**
+     * Checks if a specification exists based on the provided filter criteria.
+     * @param filter - The filter criteria to apply.
+     * @returns Whether the specification exists.
+     */
     specificationExists(filter?: Types.SpecificationFilter): Promise<Types.SpecificationExistsQuery>;
+    /**
+     * Retrieves available LLM models based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving models.
+     * @returns The available models.
+     */
     queryModels(filter?: Types.ModelFilter): Promise<Types.QueryModelsQuery>;
+    /**
+     * Creates a connector for external integrations.
+     * @param connector - The connector to create.
+     * @returns The created connector.
+     */
     createConnector(connector: Types.ConnectorInput): Promise<Types.CreateConnectorMutation>;
+    /**
+     * Updates a connector.
+     * @param connector - The connector to update.
+     * @returns The updated connector.
+     */
     updateConnector(connector: Types.ConnectorUpdateInput): Promise<Types.UpdateConnectorMutation>;
+    /**
+     * Deletes a connector.
+     * @param id - The ID of the connector to delete.
+     * @returns The deleted connector.
+     */
     deleteConnector(id: string): Promise<Types.DeleteConnectorMutation>;
+    /**
+     * Lookup a connector given its ID.
+     * @param id - ID of the connector.
+     * @returns The connector.
+     */
     getConnector(id: string): Promise<Types.GetConnectorQuery>;
+    /**
+     * Retrieves connectors based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving connectors.
+     * @returns The connectors.
+     */
     queryConnectors(filter?: Types.ConnectorFilter): Promise<Types.QueryConnectorsQuery>;
+    /**
+     * Counts connectors based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting connectors.
+     * @returns The count of connectors.
+     */
     countConnectors(filter?: Types.ConnectorFilter): Promise<Types.CountConnectorsQuery>;
+    /**
+     * Creates a view for content filtering.
+     * @param view - The view to create.
+     * @returns The created view.
+     */
     createView(view: Types.ViewInput): Promise<Types.CreateViewMutation>;
+    /**
+     * Updates a view.
+     * @param view - The view to update.
+     * @returns The updated view.
+     */
     updateView(view: Types.ViewUpdateInput): Promise<Types.UpdateViewMutation>;
+    /**
+     * Creates or updates a view.
+     * @param view - The view to create or update.
+     * @returns The created or updated view.
+     */
     upsertView(view: Types.ViewInput): Promise<Types.UpsertViewMutation>;
+    /**
+     * Deletes a view.
+     * @param id - The ID of the view to delete.
+     * @returns The deleted view.
+     */
     deleteView(id: string): Promise<Types.DeleteViewMutation>;
+    /**
+     * Deletes multiple views.
+     * @param ids - The IDs of the views to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted views.
+     */
     deleteViews(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteViewsMutation>;
+    /**
+     * Deletes all views based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting views.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllViews(filter?: Types.ViewFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllViewsMutation>;
+    /**
+     * Lookup a view given its ID.
+     * @param id - ID of the view.
+     * @returns The view.
+     */
     getView(id: string): Promise<Types.GetViewQuery>;
+    /**
+     * Retrieves views based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving views.
+     * @returns The views.
+     */
     queryViews(filter?: Types.ViewFilter): Promise<Types.QueryViewsQuery>;
+    /**
+     * Counts views based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting views.
+     * @returns The count of views.
+     */
     countViews(filter?: Types.ViewFilter): Promise<Types.CountViewsQuery>;
+    /**
+     * Checks if a view exists based on the provided filter criteria.
+     * @param filter - The filter criteria to apply.
+     * @returns Whether the view exists.
+     */
     viewExists(filter?: Types.ViewFilter): Promise<Types.ViewExistsQuery>;
+    /**
+     * Creates a workflow for content processing.
+     * @param workflow - The workflow to create.
+     * @returns The created workflow.
+     */
     createWorkflow(workflow: Types.WorkflowInput): Promise<Types.CreateWorkflowMutation>;
+    /**
+     * Updates a workflow.
+     * @param workflow - The workflow to update.
+     * @returns The updated workflow.
+     */
     updateWorkflow(workflow: Types.WorkflowUpdateInput): Promise<Types.UpdateWorkflowMutation>;
+    /**
+     * Creates or updates a workflow.
+     * @param workflow - The workflow to create or update.
+     * @returns The created or updated workflow.
+     */
     upsertWorkflow(workflow: Types.WorkflowInput): Promise<Types.UpsertWorkflowMutation>;
+    /**
+     * Deletes a workflow.
+     * @param id - The ID of the workflow to delete.
+     * @returns The deleted workflow.
+     */
     deleteWorkflow(id: string): Promise<Types.DeleteWorkflowMutation>;
+    /**
+     * Deletes multiple workflows.
+     * @param ids - The IDs of the workflows to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted workflows.
+     */
     deleteWorkflows(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteWorkflowsMutation>;
+    /**
+     * Deletes all workflows based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting workflows.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllWorkflows(filter?: Types.WorkflowFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllWorkflowsMutation>;
+    /**
+     * Lookup a workflow given its ID.
+     * @param id - ID of the workflow.
+     * @returns The workflow.
+     */
     getWorkflow(id: string): Promise<Types.GetWorkflowQuery>;
+    /**
+     * Retrieves workflows based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving workflows.
+     * @returns The workflows.
+     */
     queryWorkflows(filter?: Types.WorkflowFilter): Promise<Types.QueryWorkflowsQuery>;
+    /**
+     * Counts workflows based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting workflows.
+     * @returns The count of workflows.
+     */
     countWorkflows(filter?: Types.WorkflowFilter): Promise<Types.CountWorkflowsQuery>;
+    /**
+     * Checks if a workflow exists based on the provided filter criteria.
+     * @param filter - The filter criteria to apply.
+     * @returns Whether the workflow exists.
+     */
     workflowExists(filter?: Types.WorkflowFilter): Promise<Types.WorkflowExistsQuery>;
+    /**
+     * Creates a user.
+     * @param user - The user to create.
+     * @returns The created user.
+     */
     createUser(user: Types.UserInput): Promise<Types.CreateUserMutation>;
+    /**
+     * Updates a user.
+     * @param user - The user to update.
+     * @returns The updated user.
+     */
     updateUser(user: Types.UserUpdateInput): Promise<Types.UpdateUserMutation>;
+    /**
+     * Deletes a user.
+     * @param id - The ID of the user to delete.
+     * @returns The deleted user.
+     */
     deleteUser(id: string): Promise<Types.DeleteUserMutation>;
+    /**
+     * Lookup a user by their external identifier.
+     * @param identifier - The external identifier.
+     * @returns The user.
+     */
     getUserByIdentifier(identifier: string): Promise<Types.GetUserByIdentifierQuery>;
+    /**
+     * Gets the current authenticated user.
+     * @returns The current user.
+     */
     getUser(): Promise<Types.GetUserQuery>;
+    /**
+     * Retrieves users based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving users.
+     * @returns The users.
+     */
     queryUsers(filter?: Types.UserFilter): Promise<Types.QueryUsersQuery>;
+    /**
+     * Counts users based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting users.
+     * @returns The count of users.
+     */
     countUsers(filter?: Types.UserFilter): Promise<Types.CountUsersQuery>;
+    /**
+     * Enables a user.
+     * @param id - The ID of the user to enable.
+     * @returns The enabled user.
+     */
     enableUser(id: string): Promise<Types.EnableUserMutation>;
+    /**
+     * Disables a user.
+     * @param id - The ID of the user to disable.
+     * @returns The disabled user.
+     */
     disableUser(id: string): Promise<Types.DisableUserMutation>;
+    /**
+     * Creates a category for content classification.
+     * @param category - The category to create.
+     * @returns The created category.
+     */
     createCategory(category: Types.CategoryInput): Promise<Types.CreateCategoryMutation>;
+    /**
+     * Updates a category.
+     * @param category - The category to update.
+     * @returns The updated category.
+     */
     updateCategory(category: Types.CategoryUpdateInput): Promise<Types.UpdateCategoryMutation>;
+    /**
+     * Creates or updates a category.
+     * @param category - The category to create or update.
+     * @returns The created or updated category.
+     */
     upsertCategory(category: Types.CategoryInput): Promise<Types.UpsertCategoryMutation>;
+    /**
+     * Deletes a category.
+     * @param id - The ID of the category to delete.
+     * @returns The deleted category.
+     */
     deleteCategory(id: string): Promise<Types.DeleteCategoryMutation>;
+    /**
+     * Deletes multiple categories.
+     * @param ids - The IDs of the categories to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted categories.
+     */
     deleteCategories(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteCategoriesMutation>;
+    /**
+     * Deletes all categories based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting categories.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllCategories(filter?: Types.CategoryFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllCategoriesMutation>;
+    /**
+     * Lookup a category given its ID.
+     * @param id - ID of the category.
+     * @returns The category.
+     */
     getCategory(id: string): Promise<Types.GetCategoryQuery>;
+    /**
+     * Retrieves categories based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving categories.
+     * @returns The categories.
+     */
     queryCategories(filter?: Types.CategoryFilter): Promise<Types.QueryCategoriesQuery>;
+    /**
+     * Counts categories based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting categories.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The count of categories.
+     */
     countCategories(filter?: Types.CategoryFilter, correlationId?: string): Promise<Types.CountCategoriesQuery>;
+    /**
+     * Creates a label for content tagging.
+     * @param label - The label to create.
+     * @returns The created label.
+     */
     createLabel(label: Types.LabelInput): Promise<Types.CreateLabelMutation>;
+    /**
+     * Updates a label.
+     * @param label - The label to update.
+     * @returns The updated label.
+     */
     updateLabel(label: Types.LabelUpdateInput): Promise<Types.UpdateLabelMutation>;
+    /**
+     * Creates or updates a label.
+     * @param label - The label to create or update.
+     * @returns The created or updated label.
+     */
     upsertLabel(label: Types.LabelInput): Promise<Types.UpsertLabelMutation>;
+    /**
+     * Deletes a label.
+     * @param id - The ID of the label to delete.
+     * @returns The deleted label.
+     */
     deleteLabel(id: string): Promise<Types.DeleteLabelMutation>;
+    /**
+     * Deletes multiple labels.
+     * @param ids - The IDs of the labels to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted labels.
+     */
     deleteLabels(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteLabelsMutation>;
+    /**
+     * Deletes all labels based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting labels.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllLabels(filter?: Types.LabelFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllLabelsMutation>;
+    /**
+     * Lookup a label given its ID.
+     * @param id - ID of the label.
+     * @returns The label.
+     */
     getLabel(id: string): Promise<Types.GetLabelQuery>;
+    /**
+     * Retrieves labels based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving labels.
+     * @returns The labels.
+     */
     queryLabels(filter?: Types.LabelFilter): Promise<Types.QueryLabelsQuery>;
+    /**
+     * Counts labels based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting labels.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The count of labels.
+     */
     countLabels(filter?: Types.LabelFilter, correlationId?: string): Promise<Types.CountLabelsQuery>;
+    /**
+     * Creates a person entity.
+     * @param person - The person to create.
+     * @returns The created person.
+     */
     createPerson(person: Types.PersonInput): Promise<Types.CreatePersonMutation>;
+    /**
+     * Updates a person entity.
+     * @param person - The person to update.
+     * @returns The updated person.
+     */
     updatePerson(person: Types.PersonUpdateInput): Promise<Types.UpdatePersonMutation>;
+    /**
+     * Deletes a person entity.
+     * @param id - The ID of the person to delete.
+     * @returns The deleted person.
+     */
     deletePerson(id: string): Promise<Types.DeletePersonMutation>;
+    /**
+     * Deletes multiple person entities.
+     * @param ids - The IDs of the persons to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted persons.
+     */
     deletePersons(ids: string[], isSynchronous?: boolean): Promise<Types.DeletePersonsMutation>;
+    /**
+     * Deletes all persons based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting persons.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllPersons(filter?: Types.PersonFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllPersonsMutation>;
+    /**
+     * Lookup a person given their ID.
+     * @param id - ID of the person.
+     * @returns The person.
+     */
     getPerson(id: string): Promise<Types.GetPersonQuery>;
+    /**
+     * Retrieves persons based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving persons.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The persons.
+     */
     queryPersons(filter?: Types.PersonFilter, correlationId?: string): Promise<Types.QueryPersonsQuery>;
+    /**
+     * Retrieves persons with clustering information.
+     * @param filter - The filter criteria to apply when retrieving persons.
+     * @param clusters - The clustering configuration.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The persons with clusters.
+     */
     queryPersonsClusters(filter?: Types.PersonFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryPersonsClustersQuery>;
+    /**
+     * Retrieves persons with expanded details.
+     * @param filter - The filter criteria to apply when retrieving persons.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The persons with expanded details.
+     */
     queryPersonsExpanded(filter?: Types.PersonFilter, correlationId?: string): Promise<Types.QueryPersonsExpandedQuery>;
+    /**
+     * Counts persons based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting persons.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The count of persons.
+     */
     countPersons(filter?: Types.PersonFilter, correlationId?: string): Promise<Types.CountPersonsQuery>;
+    /**
+     * Enriches persons using an external connector.
+     * @param connector - The enrichment connector configuration.
+     * @param filter - The filter criteria to apply when selecting persons.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The enrichment result.
+     */
     enrichPersons(connector: Types.EntityEnrichmentConnectorInput, filter?: Types.PersonFilter, correlationId?: string): Promise<Types.EnrichPersonsMutation>;
+    /**
+     * Creates an organization entity.
+     * @param organization - The organization to create.
+     * @returns The created organization.
+     */
     createOrganization(organization: Types.OrganizationInput): Promise<Types.CreateOrganizationMutation>;
+    /**
+     * Updates an organization entity.
+     * @param organization - The organization to update.
+     * @returns The updated organization.
+     */
     updateOrganization(organization: Types.OrganizationUpdateInput): Promise<Types.UpdateOrganizationMutation>;
+    /**
+     * Deletes an organization entity.
+     * @param id - The ID of the organization to delete.
+     * @returns The deleted organization.
+     */
     deleteOrganization(id: string): Promise<Types.DeleteOrganizationMutation>;
+    /**
+     * Deletes multiple organization entities.
+     * @param ids - The IDs of the organizations to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted organizations.
+     */
     deleteOrganizations(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteOrganizationsMutation>;
+    /**
+     * Deletes all organizations based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting organizations.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllOrganizations(filter?: Types.OrganizationFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllOrganizationsMutation>;
+    /**
+     * Lookup an organization given its ID.
+     * @param id - ID of the organization.
+     * @returns The organization.
+     */
     getOrganization(id: string): Promise<Types.GetOrganizationQuery>;
+    /**
+     * Retrieves organizations based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving organizations.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The organizations.
+     */
     queryOrganizations(filter?: Types.OrganizationFilter, correlationId?: string): Promise<Types.QueryOrganizationsQuery>;
+    /**
+     * Retrieves organizations with clustering information.
+     * @param filter - The filter criteria to apply when retrieving organizations.
+     * @param clusters - The clustering configuration.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The organizations with clusters.
+     */
     queryOrganizationsClusters(filter?: Types.OrganizationFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryOrganizationsClustersQuery>;
+    /**
+     * Retrieves organizations with expanded details.
+     * @param filter - The filter criteria to apply when retrieving organizations.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The organizations with expanded details.
+     */
     queryOrganizationsExpanded(filter?: Types.OrganizationFilter, correlationId?: string): Promise<Types.QueryOrganizationsExpandedQuery>;
+    /**
+     * Counts organizations based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting organizations.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The count of organizations.
+     */
     countOrganizations(filter?: Types.OrganizationFilter, correlationId?: string): Promise<Types.CountOrganizationsQuery>;
+    /**
+     * Enriches organizations using an external connector.
+     * @param connector - The enrichment connector configuration.
+     * @param filter - The filter criteria to apply when selecting organizations.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The enrichment result.
+     */
     enrichOrganizations(connector: Types.EntityEnrichmentConnectorInput, filter?: Types.OrganizationFilter, correlationId?: string): Promise<Types.EnrichOrganizationsMutation>;
+    /**
+     * Creates a place entity.
+     * @param place - The place to create.
+     * @returns The created place.
+     */
     createPlace(place: Types.PlaceInput): Promise<Types.CreatePlaceMutation>;
+    /**
+     * Updates a place entity.
+     * @param place - The place to update.
+     * @returns The updated place.
+     */
     updatePlace(place: Types.PlaceUpdateInput): Promise<Types.UpdatePlaceMutation>;
+    /**
+     * Deletes a place entity.
+     * @param id - The ID of the place to delete.
+     * @returns The deleted place.
+     */
     deletePlace(id: string): Promise<Types.DeletePlaceMutation>;
+    /**
+     * Deletes multiple place entities.
+     * @param ids - The IDs of the places to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted places.
+     */
     deletePlaces(ids: string[], isSynchronous?: boolean): Promise<Types.DeletePlacesMutation>;
+    /**
+     * Deletes all places based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting places.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllPlaces(filter?: Types.PlaceFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllPlacesMutation>;
+    /**
+     * Lookup a place given its ID.
+     * @param id - ID of the place.
+     * @returns The place.
+     */
     getPlace(id: string): Promise<Types.GetPlaceQuery>;
+    /**
+     * Retrieves places based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving places.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The places.
+     */
     queryPlaces(filter?: Types.PlaceFilter, correlationId?: string): Promise<Types.QueryPlacesQuery>;
+    /**
+     * Retrieves places with clustering information.
+     * @param filter - The filter criteria to apply when retrieving places.
+     * @param clusters - The clustering configuration.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The places with clusters.
+     */
     queryPlacesClusters(filter?: Types.PlaceFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryPlacesClustersQuery>;
+    /**
+     * Counts places based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting places.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The count of places.
+     */
     countPlaces(filter?: Types.PlaceFilter, correlationId?: string): Promise<Types.CountPlacesQuery>;
+    /**
+     * Enriches places using an external connector.
+     * @param connector - The enrichment connector configuration.
+     * @param filter - The filter criteria to apply when selecting places.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The enrichment result.
+     */
     enrichPlaces(connector: Types.EntityEnrichmentConnectorInput, filter?: Types.PlaceFilter, correlationId?: string): Promise<Types.EnrichPlacesMutation>;
+    /**
+     * Creates an event entity.
+     * @param event - The event to create.
+     * @returns The created event.
+     */
     createEvent(event: Types.EventInput): Promise<Types.CreateEventMutation>;
+    /**
+     * Updates an event entity.
+     * @param event - The event to update.
+     * @returns The updated event.
+     */
     updateEvent(event: Types.EventUpdateInput): Promise<Types.UpdateEventMutation>;
+    /**
+     * Deletes an event entity.
+     * @param id - The ID of the event to delete.
+     * @returns The deleted event.
+     */
     deleteEvent(id: string): Promise<Types.DeleteEventMutation>;
+    /**
+     * Deletes multiple event entities.
+     * @param ids - The IDs of the events to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted events.
+     */
     deleteEvents(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteEventsMutation>;
+    /**
+     * Deletes all events based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting events.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllEvents(filter?: Types.EventFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllEventsMutation>;
+    /**
+     * Lookup an event given its ID.
+     * @param id - ID of the event.
+     * @returns The event.
+     */
     getEvent(id: string): Promise<Types.GetEventQuery>;
+    /**
+     * Retrieves events based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving events.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The events.
+     */
     queryEvents(filter?: Types.EventFilter, correlationId?: string): Promise<Types.QueryEventsQuery>;
+    /**
+     * Retrieves events with clustering information.
+     * @param filter - The filter criteria to apply when retrieving events.
+     * @param clusters - The clustering configuration.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The events with clusters.
+     */
     queryEventsClusters(filter?: Types.EventFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryEventsClustersQuery>;
+    /**
+     * Counts events based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting events.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The count of events.
+     */
     countEvents(filter?: Types.EventFilter, correlationId?: string): Promise<Types.CountEventsQuery>;
+    /**
+     * Creates a product entity.
+     * @param product - The product to create.
+     * @returns The created product.
+     */
     createProduct(product: Types.ProductInput): Promise<Types.CreateProductMutation>;
+    /**
+     * Updates a product entity.
+     * @param product - The product to update.
+     * @returns The updated product.
+     */
     updateProduct(product: Types.ProductUpdateInput): Promise<Types.UpdateProductMutation>;
+    /**
+     * Deletes a product entity.
+     * @param id - The ID of the product to delete.
+     * @returns The deleted product.
+     */
     deleteProduct(id: string): Promise<Types.DeleteProductMutation>;
+    /**
+     * Deletes multiple product entities.
+     * @param ids - The IDs of the products to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted products.
+     */
     deleteProducts(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteProductsMutation>;
+    /**
+     * Deletes all products based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting products.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllProducts(filter?: Types.ProductFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllProductsMutation>;
+    /**
+     * Lookup a product given its ID.
+     * @param id - ID of the product.
+     * @returns The product.
+     */
     getProduct(id: string): Promise<Types.GetProductQuery>;
+    /**
+     * Retrieves products based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving products.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The products.
+     */
     queryProducts(filter?: Types.ProductFilter, correlationId?: string): Promise<Types.QueryProductsQuery>;
+    /**
+     * Retrieves products with clustering information.
+     * @param filter - The filter criteria to apply when retrieving products.
+     * @param clusters - The clustering configuration.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The products with clusters.
+     */
     queryProductsClusters(filter?: Types.ProductFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryProductsClustersQuery>;
+    /**
+     * Counts products based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting products.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The count of products.
+     */
     countProducts(filter?: Types.ProductFilter, correlationId?: string): Promise<Types.CountProductsQuery>;
+    /**
+     * Enriches products using an external connector.
+     * @param connector - The enrichment connector configuration.
+     * @param filter - The filter criteria to apply when selecting products.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The enrichment result.
+     */
     enrichProducts(connector: Types.EntityEnrichmentConnectorInput, filter?: Types.ProductFilter, correlationId?: string): Promise<Types.EnrichProductsMutation>;
+    /**
+     * Creates a repo (code repository) entity.
+     * @param repo - The repo to create.
+     * @returns The created repo.
+     */
     createRepo(repo: Types.RepoInput): Promise<Types.CreateRepoMutation>;
+    /**
+     * Updates a repo entity.
+     * @param repo - The repo to update.
+     * @returns The updated repo.
+     */
     updateRepo(repo: Types.RepoUpdateInput): Promise<Types.UpdateRepoMutation>;
+    /**
+     * Deletes a repo entity.
+     * @param id - The ID of the repo to delete.
+     * @returns The deleted repo.
+     */
     deleteRepo(id: string): Promise<Types.DeleteRepoMutation>;
+    /**
+     * Deletes multiple repo entities.
+     * @param ids - The IDs of the repos to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted repos.
+     */
     deleteRepos(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteReposMutation>;
+    /**
+     * Deletes all repos based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting repos.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllRepos(filter?: Types.RepoFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllReposMutation>;
+    /**
+     * Lookup a repo given its ID.
+     * @param id - ID of the repo.
+     * @returns The repo.
+     */
     getRepo(id: string): Promise<Types.GetRepoQuery>;
+    /**
+     * Retrieves repos based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving repos.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The repos.
+     */
     queryRepos(filter?: Types.RepoFilter, correlationId?: string): Promise<Types.QueryReposQuery>;
+    /**
+     * Retrieves repos with clustering information.
+     * @param filter - The filter criteria to apply when retrieving repos.
+     * @param clusters - The clustering configuration.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The repos with clusters.
+     */
     queryReposClusters(filter?: Types.RepoFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryReposClustersQuery>;
+    /**
+     * Counts repos based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting repos.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The count of repos.
+     */
     countRepos(filter?: Types.RepoFilter, correlationId?: string): Promise<Types.CountReposQuery>;
+    /**
+     * Creates a software entity.
+     * @param software - The software to create.
+     * @returns The created software.
+     */
     createSoftware(software: Types.SoftwareInput): Promise<Types.CreateSoftwareMutation>;
+    /**
+     * Updates a software entity.
+     * @param software - The software to update.
+     * @returns The updated software.
+     */
     updateSoftware(software: Types.SoftwareUpdateInput): Promise<Types.UpdateSoftwareMutation>;
+    /**
+     * Deletes a software entity.
+     * @param id - The ID of the software to delete.
+     * @returns The deleted software.
+     */
     deleteSoftware(id: string): Promise<Types.DeleteSoftwareMutation>;
+    /**
+     * Deletes multiple software entities.
+     * @param ids - The IDs of the software to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted software.
+     */
     deleteSoftwares(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteSoftwaresMutation>;
+    /**
+     * Deletes all software based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting software.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
     deleteAllSoftwares(filter?: Types.SoftwareFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllSoftwaresMutation>;
+    /**
+     * Lookup a software given its ID.
+     * @param id - ID of the software.
+     * @returns The software.
+     */
     getSoftware(id: string): Promise<Types.GetSoftwareQuery>;
+    /**
+     * Retrieves software based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving software.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The software.
+     */
     querySoftwares(filter?: Types.SoftwareFilter, correlationId?: string): Promise<Types.QuerySoftwaresQuery>;
+    /**
+     * Retrieves software with clustering information.
+     * @param filter - The filter criteria to apply when retrieving software.
+     * @param clusters - The clustering configuration.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The software with clusters.
+     */
     querySoftwaresClusters(filter?: Types.SoftwareFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QuerySoftwaresClustersQuery>;
+    /**
+     * Counts software based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting software.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The count of software.
+     */
     countSoftwares(filter?: Types.SoftwareFilter, correlationId?: string): Promise<Types.CountSoftwaresQuery>;
+    /** Creates a medical condition entity. */
     createMedicalCondition(MedicalCondition: Types.MedicalConditionInput): Promise<Types.CreateMedicalConditionMutation>;
+    /** Updates a medical condition entity. */
     updateMedicalCondition(MedicalCondition: Types.MedicalConditionUpdateInput): Promise<Types.UpdateMedicalConditionMutation>;
+    /** Deletes a medical condition entity. */
     deleteMedicalCondition(id: string): Promise<Types.DeleteMedicalConditionMutation>;
+    /** Deletes multiple medical condition entities. */
     deleteMedicalConditions(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteMedicalConditionsMutation>;
+    /** Deletes all medical conditions based on filter criteria. */
     deleteAllMedicalConditions(filter?: Types.MedicalConditionFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalConditionsMutation>;
+    /** Lookup a medical condition given its ID. */
     getMedicalCondition(id: string): Promise<Types.GetMedicalConditionQuery>;
+    /** Retrieves medical conditions based on filter criteria. */
     queryMedicalConditions(filter?: Types.MedicalConditionFilter, correlationId?: string): Promise<Types.QueryMedicalConditionsQuery>;
+    /** Retrieves medical conditions with clustering information. */
     queryMedicalConditionsClusters(filter?: Types.MedicalConditionFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryMedicalConditionsClustersQuery>;
+    /** Counts medical conditions based on filter criteria. */
     countMedicalConditions(filter?: Types.MedicalConditionFilter, correlationId?: string): Promise<Types.CountMedicalConditionsQuery>;
+    /** Creates a medical guideline entity. */
     createMedicalGuideline(MedicalGuideline: Types.MedicalGuidelineInput): Promise<Types.CreateMedicalGuidelineMutation>;
+    /** Updates a medical guideline entity. */
     updateMedicalGuideline(MedicalGuideline: Types.MedicalGuidelineUpdateInput): Promise<Types.UpdateMedicalGuidelineMutation>;
+    /** Deletes a medical guideline entity. */
     deleteMedicalGuideline(id: string): Promise<Types.DeleteMedicalGuidelineMutation>;
+    /** Deletes multiple medical guideline entities. */
     deleteMedicalGuidelines(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteMedicalGuidelinesMutation>;
+    /** Deletes all medical guidelines based on filter criteria. */
     deleteAllMedicalGuidelines(filter?: Types.MedicalGuidelineFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalGuidelinesMutation>;
+    /** Lookup a medical guideline given its ID. */
     getMedicalGuideline(id: string): Promise<Types.GetMedicalGuidelineQuery>;
+    /** Retrieves medical guidelines based on filter criteria. */
     queryMedicalGuidelines(filter?: Types.MedicalGuidelineFilter, correlationId?: string): Promise<Types.QueryMedicalGuidelinesQuery>;
+    /** Retrieves medical guidelines with clustering information. */
     queryMedicalGuidelinesClusters(filter?: Types.MedicalGuidelineFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryMedicalGuidelinesClustersQuery>;
     countMedicalGuidelines(filter?: Types.MedicalGuidelineFilter, correlationId?: string): Promise<Types.CountMedicalGuidelinesQuery>;
+    /** Creates a medical drug entity. */
     createMedicalDrug(MedicalDrug: Types.MedicalDrugInput): Promise<Types.CreateMedicalDrugMutation>;
+    /** Updates a medical drug entity. */
     updateMedicalDrug(MedicalDrug: Types.MedicalDrugUpdateInput): Promise<Types.UpdateMedicalDrugMutation>;
+    /** Deletes a medical drug entity. */
     deleteMedicalDrug(id: string): Promise<Types.DeleteMedicalDrugMutation>;
+    /** Deletes multiple medical drug entities. */
     deleteMedicalDrugs(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteMedicalDrugsMutation>;
+    /** Deletes all medical drugs based on filter criteria. */
     deleteAllMedicalDrugs(filter?: Types.MedicalDrugFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalDrugsMutation>;
+    /** Lookup a medical drug given its ID. */
     getMedicalDrug(id: string): Promise<Types.GetMedicalDrugQuery>;
+    /** Retrieves medical drugs based on filter criteria. */
     queryMedicalDrugs(filter?: Types.MedicalDrugFilter, correlationId?: string): Promise<Types.QueryMedicalDrugsQuery>;
+    /** Retrieves medical drugs with clustering information. */
     queryMedicalDrugsClusters(filter?: Types.MedicalDrugFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryMedicalDrugsClustersQuery>;
+    /** Counts medical drugs based on filter criteria. */
     countMedicalDrugs(filter?: Types.MedicalDrugFilter, correlationId?: string): Promise<Types.CountMedicalDrugsQuery>;
+    /** Creates a medical indication entity. */
     createMedicalIndication(MedicalIndication: Types.MedicalIndicationInput): Promise<Types.CreateMedicalIndicationMutation>;
+    /** Updates a medical indication entity. */
     updateMedicalIndication(MedicalIndication: Types.MedicalIndicationUpdateInput): Promise<Types.UpdateMedicalIndicationMutation>;
+    /** Deletes a medical indication entity. */
     deleteMedicalIndication(id: string): Promise<Types.DeleteMedicalIndicationMutation>;
+    /** Deletes multiple medical indication entities. */
     deleteMedicalIndications(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteMedicalIndicationsMutation>;
+    /** Deletes all medical indications based on filter criteria. */
     deleteAllMedicalIndications(filter?: Types.MedicalIndicationFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalIndicationsMutation>;
+    /** Lookup a medical indication given its ID. */
     getMedicalIndication(id: string): Promise<Types.GetMedicalIndicationQuery>;
+    /** Retrieves medical indications based on filter criteria. */
     queryMedicalIndications(filter?: Types.MedicalIndicationFilter, correlationId?: string): Promise<Types.QueryMedicalIndicationsQuery>;
+    /** Retrieves medical indications with clustering information. */
     queryMedicalIndicationsClusters(filter?: Types.MedicalIndicationFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryMedicalIndicationsClustersQuery>;
+    /** Counts medical indications based on filter criteria. */
     countMedicalIndications(filter?: Types.MedicalIndicationFilter, correlationId?: string): Promise<Types.CountMedicalIndicationsQuery>;
+    /** Creates a medical contraindication entity. */
     createMedicalContraindication(MedicalContraindication: Types.MedicalContraindicationInput): Promise<Types.CreateMedicalContraindicationMutation>;
+    /** Updates a medical contraindication entity. */
     updateMedicalContraindication(MedicalContraindication: Types.MedicalContraindicationUpdateInput): Promise<Types.UpdateMedicalContraindicationMutation>;
+    /** Deletes a medical contraindication entity. */
     deleteMedicalContraindication(id: string): Promise<Types.DeleteMedicalContraindicationMutation>;
+    /** Deletes multiple medical contraindication entities. */
     deleteMedicalContraindications(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteMedicalContraindicationsMutation>;
+    /** Deletes all medical contraindications based on filter criteria. */
     deleteAllMedicalContraindications(filter?: Types.MedicalContraindicationFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalContraindicationsMutation>;
+    /** Lookup a medical contraindication given its ID. */
     getMedicalContraindication(id: string): Promise<Types.GetMedicalContraindicationQuery>;
+    /** Retrieves medical contraindications based on filter criteria. */
     queryMedicalContraindications(filter?: Types.MedicalContraindicationFilter, correlationId?: string): Promise<Types.QueryMedicalContraindicationsQuery>;
+    /** Retrieves medical contraindications with clustering information. */
     queryMedicalContraindicationsClusters(filter?: Types.MedicalContraindicationFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryMedicalContraindicationsClustersQuery>;
+    /** Counts medical contraindications based on filter criteria. */
     countMedicalContraindications(filter?: Types.MedicalContraindicationFilter, correlationId?: string): Promise<Types.CountMedicalContraindicationsQuery>;
+    /** Creates a medical test entity. */
     createMedicalTest(MedicalTest: Types.MedicalTestInput): Promise<Types.CreateMedicalTestMutation>;
+    /** Updates a medical test entity. */
     updateMedicalTest(MedicalTest: Types.MedicalTestUpdateInput): Promise<Types.UpdateMedicalTestMutation>;
+    /** Deletes a medical test entity. */
     deleteMedicalTest(id: string): Promise<Types.DeleteMedicalTestMutation>;
+    /** Deletes multiple medical test entities. */
     deleteMedicalTests(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteMedicalTestsMutation>;
+    /** Deletes all medical tests based on filter criteria. */
     deleteAllMedicalTests(filter?: Types.MedicalTestFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalTestsMutation>;
+    /** Lookup a medical test given its ID. */
     getMedicalTest(id: string): Promise<Types.GetMedicalTestQuery>;
+    /** Retrieves medical tests based on filter criteria. */
     queryMedicalTests(filter?: Types.MedicalTestFilter, correlationId?: string): Promise<Types.QueryMedicalTestsQuery>;
+    /** Retrieves medical tests with clustering information. */
     queryMedicalTestsClusters(filter?: Types.MedicalTestFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryMedicalTestsClustersQuery>;
+    /** Counts medical tests based on filter criteria. */
     countMedicalTests(filter?: Types.MedicalTestFilter, correlationId?: string): Promise<Types.CountMedicalTestsQuery>;
+    /** Creates a medical device entity. */
     createMedicalDevice(MedicalDevice: Types.MedicalDeviceInput): Promise<Types.CreateMedicalDeviceMutation>;
+    /** Updates a medical device entity. */
     updateMedicalDevice(MedicalDevice: Types.MedicalDeviceUpdateInput): Promise<Types.UpdateMedicalDeviceMutation>;
+    /** Deletes a medical device entity. */
     deleteMedicalDevice(id: string): Promise<Types.DeleteMedicalDeviceMutation>;
+    /** Deletes multiple medical device entities. */
     deleteMedicalDevices(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteMedicalDevicesMutation>;
+    /** Deletes all medical devices based on filter criteria. */
     deleteAllMedicalDevices(filter?: Types.MedicalDeviceFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalDevicesMutation>;
+    /** Lookup a medical device given its ID. */
     getMedicalDevice(id: string): Promise<Types.GetMedicalDeviceQuery>;
+    /** Retrieves medical devices based on filter criteria. */
     queryMedicalDevices(filter?: Types.MedicalDeviceFilter, correlationId?: string): Promise<Types.QueryMedicalDevicesQuery>;
+    /** Retrieves medical devices with clustering information. */
     queryMedicalDevicesClusters(filter?: Types.MedicalDeviceFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryMedicalDevicesClustersQuery>;
+    /** Counts medical devices based on filter criteria. */
     countMedicalDevices(filter?: Types.MedicalDeviceFilter, correlationId?: string): Promise<Types.CountMedicalDevicesQuery>;
+    /** Creates a medical procedure entity. */
     createMedicalProcedure(MedicalProcedure: Types.MedicalProcedureInput): Promise<Types.CreateMedicalProcedureMutation>;
+    /** Updates a medical procedure entity. */
     updateMedicalProcedure(MedicalProcedure: Types.MedicalProcedureUpdateInput): Promise<Types.UpdateMedicalProcedureMutation>;
+    /** Deletes a medical procedure entity. */
     deleteMedicalProcedure(id: string): Promise<Types.DeleteMedicalProcedureMutation>;
+    /** Deletes multiple medical procedure entities. */
     deleteMedicalProcedures(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteMedicalProceduresMutation>;
+    /** Deletes all medical procedures based on filter criteria. */
     deleteAllMedicalProcedures(filter?: Types.MedicalProcedureFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalProceduresMutation>;
+    /** Lookup a medical procedure given its ID. */
     getMedicalProcedure(id: string): Promise<Types.GetMedicalProcedureQuery>;
+    /** Retrieves medical procedures based on filter criteria. */
     queryMedicalProcedures(filter?: Types.MedicalProcedureFilter, correlationId?: string): Promise<Types.QueryMedicalProceduresQuery>;
+    /** Retrieves medical procedures with clustering information. */
     queryMedicalProceduresClusters(filter?: Types.MedicalProcedureFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryMedicalProceduresClustersQuery>;
+    /** Counts medical procedures based on filter criteria. */
     countMedicalProcedures(filter?: Types.MedicalProcedureFilter, correlationId?: string): Promise<Types.CountMedicalProceduresQuery>;
+    /** Creates a medical study entity. */
     createMedicalStudy(MedicalStudy: Types.MedicalStudyInput): Promise<Types.CreateMedicalStudyMutation>;
+    /** Updates a medical study entity. */
     updateMedicalStudy(MedicalStudy: Types.MedicalStudyUpdateInput): Promise<Types.UpdateMedicalStudyMutation>;
+    /** Deletes a medical study entity. */
     deleteMedicalStudy(id: string): Promise<Types.DeleteMedicalStudyMutation>;
+    /** Deletes multiple medical study entities. */
     deleteMedicalStudies(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteMedicalStudiesMutation>;
+    /** Deletes all medical studies based on filter criteria. */
     deleteAllMedicalStudies(filter?: Types.MedicalStudyFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalStudiesMutation>;
+    /** Lookup a medical study given its ID. */
     getMedicalStudy(id: string): Promise<Types.GetMedicalStudyQuery>;
+    /** Retrieves medical studies based on filter criteria. */
     queryMedicalStudies(filter?: Types.MedicalStudyFilter, correlationId?: string): Promise<Types.QueryMedicalStudiesQuery>;
+    /** Retrieves medical studies with clustering information. */
     queryMedicalStudiesClusters(filter?: Types.MedicalStudyFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryMedicalStudiesClustersQuery>;
+    /** Counts medical studies based on filter criteria. */
     countMedicalStudies(filter?: Types.MedicalStudyFilter, correlationId?: string): Promise<Types.CountMedicalStudiesQuery>;
+    /** Creates a medical drug class entity. */
     createMedicalDrugClass(MedicalDrugClass: Types.MedicalDrugClassInput): Promise<Types.CreateMedicalDrugClassMutation>;
+    /** Updates a medical drug class entity. */
     updateMedicalDrugClass(MedicalDrugClass: Types.MedicalDrugClassUpdateInput): Promise<Types.UpdateMedicalDrugClassMutation>;
+    /** Deletes a medical drug class entity. */
     deleteMedicalDrugClass(id: string): Promise<Types.DeleteMedicalDrugClassMutation>;
+    /** Deletes multiple medical drug class entities. */
     deleteMedicalDrugClasses(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteMedicalDrugClassesMutation>;
+    /** Deletes all medical drug classes based on filter criteria. */
     deleteAllMedicalDrugClasses(filter?: Types.MedicalDrugClassFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalDrugClassesMutation>;
+    /** Lookup a medical drug class given its ID. */
     getMedicalDrugClass(id: string): Promise<Types.GetMedicalDrugClassQuery>;
+    /** Retrieves medical drug classes based on filter criteria. */
     queryMedicalDrugClasses(filter?: Types.MedicalDrugClassFilter, correlationId?: string): Promise<Types.QueryMedicalDrugClassesQuery>;
+    /** Retrieves medical drug classes with clustering information. */
     queryMedicalDrugClassesClusters(filter?: Types.MedicalDrugClassFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryMedicalDrugClassesClustersQuery>;
+    /** Counts medical drug classes based on filter criteria. */
     countMedicalDrugClasses(filter?: Types.MedicalDrugClassFilter, correlationId?: string): Promise<Types.CountMedicalDrugClassesQuery>;
+    /** Creates a medical therapy entity. */
     createMedicalTherapy(MedicalTherapy: Types.MedicalTherapyInput): Promise<Types.CreateMedicalTherapyMutation>;
+    /** Updates a medical therapy entity. */
     updateMedicalTherapy(MedicalTherapy: Types.MedicalTherapyUpdateInput): Promise<Types.UpdateMedicalTherapyMutation>;
+    /** Deletes a medical therapy entity. */
     deleteMedicalTherapy(id: string): Promise<Types.DeleteMedicalTherapyMutation>;
+    /** Deletes multiple medical therapy entities. */
     deleteMedicalTherapies(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteMedicalTherapiesMutation>;
+    /** Deletes all medical therapies based on filter criteria. */
     deleteAllMedicalTherapies(filter?: Types.MedicalTherapyFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalTherapiesMutation>;
+    /** Lookup a medical therapy given its ID. */
     getMedicalTherapy(id: string): Promise<Types.GetMedicalTherapyQuery>;
+    /** Retrieves medical therapies based on filter criteria. */
     queryMedicalTherapies(filter?: Types.MedicalTherapyFilter, correlationId?: string): Promise<Types.QueryMedicalTherapiesQuery>;
+    /** Retrieves medical therapies with clustering information. */
     queryMedicalTherapiesClusters(filter?: Types.MedicalTherapyFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryMedicalTherapiesClustersQuery>;
+    /** Counts medical therapies based on filter criteria. */
     countMedicalTherapies(filter?: Types.MedicalTherapyFilter, correlationId?: string): Promise<Types.CountMedicalTherapiesQuery>;
+    /** Creates an observation entity. */
     createObservation(observation: Types.ObservationInput): Promise<Types.CreateObservationMutation>;
+    /** Updates an observation entity. */
     updateObservation(observation: Types.ObservationUpdateInput): Promise<Types.UpdateObservationMutation>;
+    /** Deletes an observation entity. */
     deleteObservation(id: string): Promise<Types.DeleteObservationMutation>;
+    /** Matches an observable against candidate entities using AI. */
     matchEntity(observable: Types.ObservableInput, candidates: Types.EntityReferenceInput[], specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.MatchEntityMutation>;
+    /** Resolves multiple entities of a given type using AI similarity matching. */
     resolveEntities(type: Types.ObservableTypes, entities: Types.EntityReferenceInput[], threshold?: number, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.ResolveEntitiesMutation>;
+    /** Resolves a source entity against a target entity using AI similarity matching. */
     resolveEntity(type: Types.ObservableTypes, source: Types.EntityReferenceInput, target: Types.EntityReferenceInput, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.ResolveEntityMutation>;
+    /** Creates an investment entity. */
     createInvestment(investment: Types.InvestmentInput): Promise<Types.CreateInvestmentMutation>;
+    /** Updates an investment entity. */
     updateInvestment(investment: Types.InvestmentUpdateInput): Promise<Types.UpdateInvestmentMutation>;
+    /** Deletes an investment entity. */
     deleteInvestment(id: string): Promise<Types.DeleteInvestmentMutation>;
+    /** Deletes multiple investment entities. */
     deleteInvestments(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteInvestmentsMutation>;
+    /** Deletes all investments based on filter criteria. */
     deleteAllInvestments(filter?: Types.InvestmentFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllInvestmentsMutation>;
+    /** Creates an investment fund entity. */
     createInvestmentFund(investmentFund: Types.InvestmentFundInput): Promise<Types.CreateInvestmentFundMutation>;
+    /** Updates an investment fund entity. */
     updateInvestmentFund(investmentFund: Types.InvestmentFundUpdateInput): Promise<Types.UpdateInvestmentFundMutation>;
+    /** Deletes an investment fund entity. */
     deleteInvestmentFund(id: string): Promise<Types.DeleteInvestmentFundMutation>;
+    /** Deletes multiple investment fund entities. */
     deleteInvestmentFunds(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteInvestmentFundsMutation>;
+    /** Deletes all investment funds based on filter criteria. */
     deleteAllInvestmentFunds(filter?: Types.InvestmentFundFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllInvestmentFundsMutation>;
+    /** Lookup an investment given its ID. */
     getInvestment(id: string, correlationId?: string): Promise<Types.GetInvestmentQuery>;
+    /** Retrieves investments based on filter criteria. */
     queryInvestments(filter?: Types.InvestmentFilter, correlationId?: string): Promise<Types.QueryInvestmentsQuery>;
+    /** Retrieves investments with clustering information. */
     queryInvestmentsClusters(filter?: Types.InvestmentFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryInvestmentsClustersQuery>;
+    /** Retrieves investments with expanded relationship data. */
     queryInvestmentsExpanded(filter?: Types.InvestmentFilter, correlationId?: string): Promise<Types.QueryInvestmentsExpandedQuery>;
+    /** Counts investments based on filter criteria. */
     countInvestments(filter?: Types.InvestmentFilter, correlationId?: string): Promise<Types.CountInvestmentsQuery>;
+    /** Lookup an investment fund given its ID. */
     getInvestmentFund(id: string, correlationId?: string): Promise<Types.GetInvestmentFundQuery>;
+    /** Retrieves investment funds based on filter criteria. */
     queryInvestmentFunds(filter?: Types.InvestmentFundFilter, correlationId?: string): Promise<Types.QueryInvestmentFundsQuery>;
+    /** Retrieves investment funds with clustering information. */
     queryInvestmentFundsClusters(filter?: Types.InvestmentFundFilter, clusters?: Types.EntityClustersInput, correlationId?: string): Promise<Types.QueryInvestmentFundsClustersQuery>;
+    /** Retrieves investment funds with expanded relationship data. */
     queryInvestmentFundsExpanded(filter?: Types.InvestmentFundFilter, correlationId?: string): Promise<Types.QueryInvestmentFundsExpandedQuery>;
+    /** Counts investment funds based on filter criteria. */
     countInvestmentFunds(filter?: Types.InvestmentFundFilter, correlationId?: string): Promise<Types.CountInvestmentFundsQuery>;
     /**
      * Creates an event handler that supports UI streaming mode