graphlit-client 1.0.20251217002 → 1.0.20251220002

package/dist/client.js

@@ -406,12 +406,28 @@ class Graphlit {
         };
         this.token = jwt.sign(payload, this.jwtSecret, { algorithm: "HS256" });
     }
+    /**
+     * Fetch current project.
+     * @returns The project.
+     */
     async getProject() {
         return this.queryAndCheckError(Documents.GetProject, {});
     }
+    /**
+     * Updates a project.
+     * @param project - The project to update.
+     * @returns The updated project.
+     */
     async updateProject(project) {
         return this.mutateAndCheckError(Documents.UpdateProject, { project: project });
     }
+    /**
+     * 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.
+     */
     async lookupProjectUsage(correlationId, startDate, duration) {
         return this.queryAndCheckError(Documents.LookupUsage, {
             correlationId: correlationId,
@@ -419,6 +435,13 @@ class Graphlit {
             duration: duration,
         });
     }
+    /**
+     * 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.
+     */
     async lookupProjectCredits(correlationId, startDate, duration) {
         return this.queryAndCheckError(Documents.LookupCredits, {
             correlationId: correlationId,
@@ -426,9 +449,25 @@ class Graphlit {
             duration: duration,
         });
     }
+    /**
+     * 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.
+     */
     async queryProjectTokens(startDate, duration) {
         return this.queryAndCheckError(Documents.QueryTokens, { startDate: startDate, duration: duration });
     }
+    /**
+     * 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.
+     */
     async queryProjectUsage(startDate, duration, names, excludedNames, offset, limit) {
         return this.queryAndCheckError(Documents.QueryUsage, {
             startDate: startDate,
@@ -439,9 +478,22 @@ class Graphlit {
             limit: limit,
         });
     }
+    /**
+     * 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.
+     */
     async queryProjectCredits(startDate, duration) {
         return this.queryAndCheckError(Documents.QueryCredits, { startDate: startDate, duration: duration });
     }
+    /**
+     * 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.
+     */
     async sendNotification(connector, text, textType) {
         return this.mutateAndCheckError(Documents.SendNotification, {
             connector: connector,
@@ -449,6 +501,14 @@ class Graphlit {
             textType: textType,
         });
     }
+    /**
+     * 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.
+     */
     async mapWeb(uri, allowedPaths, excludedPaths, correlationId) {
         return this.queryAndCheckError(Documents.MapWeb, {
             uri: uri,
@@ -457,6 +517,14 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async searchWeb(text, service, limit, correlationId) {
         return this.queryAndCheckError(Documents.SearchWeb, {
             text: text,
@@ -465,21 +533,55 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Creates an alert.
+     * @param alert - The alert to create.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The created alert.
+     */
     async createAlert(alert, correlationId) {
         return this.mutateAndCheckError(Documents.CreateAlert, { alert: alert, correlationId: correlationId });
     }
+    /**
+     * Updates an alert.
+     * @param alert - The alert to update.
+     * @returns The updated alert.
+     */
     async updateAlert(alert) {
         return this.mutateAndCheckError(Documents.UpdateAlert, { alert: alert });
     }
+    /**
+     * Creates or updates an alert.
+     * @param alert - The alert to create or update.
+     * @returns The created or updated alert.
+     */
     async upsertAlert(alert) {
         return this.mutateAndCheckError(Documents.UpsertAlert, { alert: alert });
     }
+    /**
+     * Deletes an alert.
+     * @param id - The ID of the alert to delete.
+     * @returns The deleted alert.
+     */
     async deleteAlert(id) {
         return this.mutateAndCheckError(Documents.DeleteAlert, { id: id });
     }
+    /**
+     * Deletes multiple alerts.
+     * @param ids - The IDs of the alerts to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted alerts.
+     */
     async deleteAlerts(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteAlerts, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllAlerts(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllAlerts, {
             filter: filter,
@@ -487,33 +589,86 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Enables an alert.
+     * @param id - The ID of the alert to enable.
+     * @returns The enabled alert.
+     */
     async enableAlert(id) {
         return this.mutateAndCheckError(Documents.EnableAlert, { id: id });
     }
+    /**
+     * Disables an alert.
+     * @param id - The ID of the alert to disable.
+     * @returns The disabled alert.
+     */
     async disableAlert(id) {
         return this.mutateAndCheckError(Documents.DisableAlert, { id: id });
     }
+    /**
+     * Lookup an alert given its ID.
+     * @param id - ID of the alert.
+     * @returns The alert.
+     */
     async getAlert(id) {
         return this.queryAndCheckError(Documents.GetAlert, { id: id });
     }
+    /**
+     * Retrieves alerts based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving alerts.
+     * @returns The alerts.
+     */
     async queryAlerts(filter) {
         return this.queryAndCheckError(Documents.QueryAlerts, { filter: filter });
     }
+    /**
+     * Counts alerts based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting alerts.
+     * @returns The count of alerts.
+     */
     async countAlerts(filter) {
         return this.queryAndCheckError(Documents.CountAlerts, { filter: filter });
     }
+    /**
+     * Creates a collection.
+     * @param collection - The collection to create.
+     * @returns The created collection.
+     */
     async createCollection(collection) {
         return this.mutateAndCheckError(Documents.CreateCollection, { collection: collection });
     }
+    /**
+     * Updates a collection.
+     * @param collection - The collection to update.
+     * @returns The updated collection.
+     */
     async updateCollection(collection) {
         return this.mutateAndCheckError(Documents.UpdateCollection, { collection: collection });
     }
+    /**
+     * Deletes a collection.
+     * @param id - The ID of the collection to delete.
+     * @returns The deleted collection.
+     */
     async deleteCollection(id) {
         return this.mutateAndCheckError(Documents.DeleteCollection, { id: id });
     }
+    /**
+     * Deletes multiple collections.
+     * @param ids - The IDs of the collections to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted collections.
+     */
     async deleteCollections(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteCollections, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllCollections(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllCollections, {
             filter: filter,
@@ -521,27 +676,62 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async addContentsToCollections(contents, collections) {
         return this.mutateAndCheckError(Documents.AddContentsToCollections, {
             contents: contents,
             collections: collections,
         });
     }
+    /**
+     * 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.
+     */
     async removeContentsFromCollection(contents, collection) {
         return this.mutateAndCheckError(Documents.RemoveContentsFromCollection, {
             contents: contents,
             collection: collection,
         });
     }
+    /**
+     * Lookup a collection given its ID.
+     * @param id - ID of the collection.
+     * @returns The collection.
+     */
     async getCollection(id) {
         return this.queryAndCheckError(Documents.GetCollection, { id: id });
     }
+    /**
+     * Retrieves collections based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving collections.
+     * @returns The collections.
+     */
     async queryCollections(filter) {
         return this.queryAndCheckError(Documents.QueryCollections, { filter: filter });
     }
+    /**
+     * Counts collections based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting collections.
+     * @returns The count of collections.
+     */
     async countCollections(filter) {
         return this.queryAndCheckError(Documents.CountCollections, { filter: filter });
     }
+    /**
+     * 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.
+     */
     async describeImage(prompt, uri, specification, correlationId) {
         return this.mutateAndCheckError(Documents.DescribeImage, {
             prompt: prompt,
@@ -550,6 +740,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async describeEncodedImage(prompt, mimeType, data, specification, correlationId) {
         return this.mutateAndCheckError(Documents.DescribeEncodedImage, {
             prompt: prompt,
@@ -559,6 +758,16 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async screenshotPage(uri, maximumHeight, isSynchronous, workflow, collections, correlationId) {
         return this.mutateAndCheckError(Documents.ScreenshotPage, {
             uri: uri,
@@ -569,6 +778,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async ingestTextBatch(batch, textType, collections, observations, correlationId) {
         return this.mutateAndCheckError(Documents.IngestTextBatch, {
             batch: batch,
@@ -578,6 +796,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async ingestBatch(uris, workflow, collections, observations, correlationId) {
         return this.mutateAndCheckError(Documents.IngestBatch, {
             uris: uris,
@@ -587,6 +814,19 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async ingestUri(uri, name, id, identifier, isSynchronous, workflow, collections, observations, correlationId) {
         return this.mutateAndCheckError(Documents.IngestUri, {
             uri: uri,
@@ -600,6 +840,21 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async ingestText(text, name, textType, uri, id, identifier, isSynchronous, workflow, collections, observations, correlationId) {
         return this.mutateAndCheckError(Documents.IngestText, {
             name: name,
@@ -615,6 +870,17 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async ingestMemory(text, name, textType, id, identifier, collections, correlationId) {
         return this.mutateAndCheckError(Documents.IngestMemory, {
             name: name,
@@ -626,6 +892,18 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async ingestEvent(markdown, name, description, eventDate, id, identifier, collections, correlationId) {
         return this.mutateAndCheckError(Documents.IngestEvent, {
             name: name,
@@ -638,6 +916,22 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async ingestEncodedFile(name, data, mimeType, fileCreationDate, fileModifiedDate, id, identifier, isSynchronous, workflow, collections, observations, correlationId) {
         return this.mutateAndCheckError(Documents.IngestEncodedFile, {
             name: name,
@@ -654,15 +948,38 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Updates content.
+     * @param content - The content to update.
+     * @returns The updated content.
+     */
     async updateContent(content) {
         return this.mutateAndCheckError(Documents.UpdateContent, { content: content });
     }
+    /**
+     * Deletes content.
+     * @param id - The ID of the content to delete.
+     * @returns The deleted content.
+     */
     async deleteContent(id) {
         return this.mutateAndCheckError(Documents.DeleteContent, { id: id });
     }
+    /**
+     * Deletes multiple contents.
+     * @param ids - The IDs of the contents to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted contents.
+     */
     async deleteContents(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteContents, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllContents(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllContents, {
             filter: filter,
@@ -670,6 +987,14 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async summarizeText(summarization, text, textType, correlationId) {
         return this.mutateAndCheckError(Documents.SummarizeText, {
             summarization: summarization,
@@ -678,6 +1003,13 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async summarizeContents(summarizations, filter, correlationId) {
         return this.mutateAndCheckError(Documents.SummarizeContents, {
             summarizations: summarizations,
@@ -685,6 +1017,16 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async extractText(prompt, text, tools, specification, textType, correlationId) {
         return this.mutateAndCheckError(Documents.ExtractText, {
             prompt: prompt,
@@ -695,6 +1037,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async extractContents(prompt, tools, specification, filter, correlationId) {
         return this.mutateAndCheckError(Documents.ExtractContents, {
             prompt: prompt,
@@ -704,6 +1055,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async extractObservables(text, textType, specification, observableTypes, correlationId) {
         return this.mutateAndCheckError(Documents.ExtractObservables, {
             text: text,
@@ -713,6 +1073,21 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async publishContents(publishPrompt, connector, summaryPrompt, summarySpecification, publishSpecification, name, filter, workflow, isSynchronous, includeDetails, correlationId) {
         return this.mutateAndCheckError(Documents.PublishContents, {
             summaryPrompt: summaryPrompt,
@@ -728,6 +1103,17 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async publishText(text, textType, connector, name, workflow, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.PublishText, {
             text: text,
@@ -739,6 +1125,17 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async researchContents(connector, filter, name, summarySpecification, publishSpecification, workflow, correlationId) {
         return this.mutateAndCheckError(Documents.ResearchContents, {
             connector: connector,
@@ -750,24 +1147,59 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup content given its ID.
+     * @param id - ID of the content.
+     * @returns The content.
+     */
     async getContent(id) {
         return this.queryAndCheckError(Documents.GetContent, { id: id });
     }
+    /**
+     * Lookup multiple contents given their IDs.
+     * @param ids - IDs of the contents.
+     * @returns The contents.
+     */
     async lookupContents(ids) {
         return this.queryAndCheckError(Documents.LookupContents, { ids: ids });
     }
+    /**
+     * Retrieves observables based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving observables.
+     * @returns The observables.
+     */
     async queryObservables(filter) {
         return this.queryAndCheckError(Documents.QueryObservables, { filter: filter });
     }
+    /**
+     * Retrieves contents based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving contents.
+     * @returns The contents.
+     */
     async queryContents(filter) {
         return this.queryAndCheckError(Documents.QueryContents, { filter: filter });
     }
+    /**
+     * 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.
+     */
     async queryContentsObservations(filter) {
         return this.queryAndCheckError(Documents.QueryContentsObservations, { filter: filter });
     }
+    /**
+     * Retrieves content facets based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving facets.
+     * @returns The content facets.
+     */
     async queryContentsFacets(filter) {
         return this.queryAndCheckError(Documents.QueryContentsFacets, { filter: filter });
     }
+    /**
+     * 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.
+     */
     async queryContentsGraph(filter) {
         return this.queryAndCheckError(Documents.QueryContentsGraph, {
             filter: filter,
@@ -776,6 +1208,13 @@ class Graphlit {
             },
         });
     }
+    /**
+     * 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.
+     */
     async queryGraph(filter, graph, correlationId) {
         return this.queryAndCheckError(Documents.QueryGraph, {
             filter: filter,
@@ -783,36 +1222,81 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async lookupEntity(filter, correlationId) {
         return this.queryAndCheckError(Documents.LookupEntity, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /**
+     * Counts contents based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting contents.
+     * @returns The count of contents.
+     */
     async countContents(filter) {
         return this.queryAndCheckError(Documents.CountContents, { filter: filter });
     }
+    /**
+     * Checks if content processing is complete.
+     * @param id - ID of the content.
+     * @returns Whether the content is done processing.
+     */
     async isContentDone(id) {
         return this.queryAndCheckError(Documents.IsContentDone, { id: id });
     }
+    /**
+     * Creates a conversation.
+     * @param conversation - The conversation to create.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The created conversation.
+     */
     async createConversation(conversation, correlationId) {
         return this.mutateAndCheckError(Documents.CreateConversation, {
             conversation: conversation,
             correlationId: correlationId,
         });
     }
+    /**
+     * Updates a conversation.
+     * @param conversation - The conversation to update.
+     * @returns The updated conversation.
+     */
     async updateConversation(conversation) {
         return this.mutateAndCheckError(Documents.UpdateConversation, { conversation: conversation });
     }
+    /**
+     * Deletes a conversation.
+     * @param id - The ID of the conversation to delete.
+     * @returns The deleted conversation.
+     */
     async deleteConversation(id) {
         return this.mutateAndCheckError(Documents.DeleteConversation, { id: id });
     }
+    /**
+     * Deletes multiple conversations.
+     * @param ids - The IDs of the conversations to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted conversations.
+     */
     async deleteConversations(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteConversations, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /**
+     * 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.
+     */
     async deleteAllConversations(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllConversations, {
             filter: filter,
@@ -820,21 +1304,55 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Clears all messages from a conversation.
+     * @param id - The ID of the conversation to clear.
+     * @returns The cleared conversation.
+     */
     async clearConversation(id) {
         return this.mutateAndCheckError(Documents.ClearConversation, { id: id });
     }
+    /**
+     * Closes a conversation.
+     * @param id - The ID of the conversation to close.
+     * @returns The closed conversation.
+     */
     async closeConversation(id) {
         return this.mutateAndCheckError(Documents.CloseConversation, { id: id });
     }
+    /**
+     * Lookup a conversation given its ID.
+     * @param id - ID of the conversation.
+     * @returns The conversation.
+     */
     async getConversation(id) {
         return this.queryAndCheckError(Documents.GetConversation, { id: id });
     }
+    /**
+     * Retrieves conversations based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving conversations.
+     * @returns The conversations.
+     */
     async queryConversations(filter) {
         return this.queryAndCheckError(Documents.QueryConversations, { filter: filter });
     }
+    /**
+     * Counts conversations based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting conversations.
+     * @returns The count of conversations.
+     */
     async countConversations(filter) {
         return this.queryAndCheckError(Documents.CountConversations, { filter: filter });
     }
+    /**
+     * 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.
+     */
     async reviseImage(prompt, uri, id, specification, correlationId) {
         return this.mutateAndCheckError(Documents.ReviseImage, {
             prompt: prompt,
@@ -844,6 +1362,16 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async reviseEncodedImage(prompt, mimeType, data, id, specification, correlationId) {
         return this.mutateAndCheckError(Documents.ReviseEncodedImage, {
             prompt: prompt,
@@ -854,6 +1382,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async reviseText(prompt, text, id, specification, correlationId) {
         return this.mutateAndCheckError(Documents.ReviseText, {
             prompt: prompt,
@@ -863,6 +1400,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async reviseContent(prompt, content, id, specification, correlationId) {
         return this.mutateAndCheckError(Documents.ReviseContent, {
             prompt: prompt,
@@ -872,6 +1418,16 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async prompt(prompt, mimeType, data, specification, messages, correlationId) {
         return this.mutateAndCheckError(Documents.Prompt, {
             prompt: prompt,
@@ -882,6 +1438,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async retrieveView(prompt, id, retrievalStrategy, rerankingStrategy, correlationId) {
         return this.mutateAndCheckError(Documents.RetrieveView, {
             prompt: prompt,
@@ -891,6 +1456,16 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async retrieveSources(prompt, filter, augmentedFilter, retrievalStrategy, rerankingStrategy, correlationId) {
         return this.mutateAndCheckError(Documents.RetrieveSources, {
             prompt: prompt,
@@ -901,6 +1476,17 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async formatConversation(prompt, id, specification, tools, systemPrompt, includeDetails, correlationId) {
         return this.mutateAndCheckError(Documents.FormatConversation, {
             prompt: prompt,
@@ -912,6 +1498,16 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async completeConversation(completion, id, completionTime, ttft, throughput, correlationId) {
         return this.mutateAndCheckError(Documents.CompleteConversation, {
             completion: completion,
@@ -922,6 +1518,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async askGraphlit(prompt, type, id, specification, correlationId) {
         return this.mutateAndCheckError(Documents.AskGraphlit, {
             prompt: prompt,
@@ -931,11 +1536,30 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Creates a branch of an existing conversation.
+     * @param id - The conversation ID to branch from.
+     * @returns The branched conversation.
+     */
     async branchConversation(id) {
         return this.mutateAndCheckError(Documents.BranchConversation, {
             id: id,
         });
     }
+    /**
+     * 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.
+     */
     async promptConversation(prompt, id, specification, mimeType, data, tools, requireTool, systemPrompt, includeDetails, correlationId) {
         return this.mutateAndCheckError(Documents.PromptConversation, {
             prompt: prompt,
@@ -950,6 +1574,13 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async continueConversation(id, responses, correlationId) {
         return this.mutateAndCheckError(Documents.ContinueConversation, {
             id: id,
@@ -957,6 +1588,16 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async publishConversation(id, connector, name, workflow, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.PublishConversation, {
             id: id,
@@ -967,6 +1608,13 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async suggestConversation(id, count, correlationId) {
         return this.mutateAndCheckError(Documents.SuggestConversation, {
             id: id,
@@ -974,40 +1622,81 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Queries Microsoft calendars.
+     * @param properties - The Microsoft calendar query properties.
+     * @returns The Microsoft calendars.
+     */
     async queryMicrosoftCalendars(properties) {
         return this.queryAndCheckError(Documents.QueryMicrosoftCalendars, {
             properties: properties,
         });
     }
+    /**
+     * Queries Google calendars.
+     * @param properties - The Google calendar query properties.
+     * @returns The Google calendars.
+     */
     async queryGoogleCalendars(properties) {
         return this.queryAndCheckError(Documents.QueryGoogleCalendars, {
             properties: properties,
         });
     }
+    /**
+     * Queries Box folders.
+     * @param properties - The Box folder query properties.
+     * @param folderId - The parent folder ID, optional.
+     * @returns The Box folders.
+     */
     async queryBoxFolders(properties, folderId) {
         return this.queryAndCheckError(Documents.QueryBoxFolders, {
             properties: properties,
             folderId: folderId,
         });
     }
+    /**
+     * Queries Dropbox folders.
+     * @param properties - The Dropbox folder query properties.
+     * @param folderPath - The folder path, optional.
+     * @returns The Dropbox folders.
+     */
     async queryDropboxFolders(properties, folderPath) {
         return this.queryAndCheckError(Documents.QueryDropboxFolders, {
             properties: properties,
             folderPath: folderPath,
         });
     }
+    /**
+     * Queries Google Drive folders.
+     * @param properties - The Google Drive folder query properties.
+     * @param folderId - The parent folder ID, optional.
+     * @returns The Google Drive folders.
+     */
     async queryGoogleDriveFolders(properties, folderId) {
         return this.queryAndCheckError(Documents.QueryGoogleDriveFolders, {
             properties: properties,
             folderId: folderId,
         });
     }
+    /**
+     * Queries OneDrive folders.
+     * @param properties - The OneDrive folder query properties.
+     * @param folderId - The parent folder ID, optional.
+     * @returns The OneDrive folders.
+     */
     async queryOneDriveFolders(properties, folderId) {
         return this.queryAndCheckError(Documents.QueryOneDriveFolders, {
             properties: properties,
             folderId: folderId,
         });
     }
+    /**
+     * 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.
+     */
     async querySharePointFolders(properties, libraryId, folderId) {
         return this.queryAndCheckError(Documents.QuerySharePointFolders, {
             properties: properties,
@@ -1015,57 +1704,139 @@ class Graphlit {
             folderId: folderId,
         });
     }
+    /**
+     * Queries SharePoint libraries.
+     * @param properties - The SharePoint library query properties.
+     * @returns The SharePoint libraries.
+     */
     async querySharePointLibraries(properties) {
         return this.queryAndCheckError(Documents.QuerySharePointLibraries, { properties: properties });
     }
+    /**
+     * Queries Microsoft Teams teams.
+     * @param properties - The Microsoft Teams query properties.
+     * @returns The Microsoft Teams teams.
+     */
     async queryMicrosoftTeamsTeams(properties) {
         return this.queryAndCheckError(Documents.QueryMicrosoftTeamsTeams, { properties: properties });
     }
+    /**
+     * Queries Microsoft Teams channels.
+     * @param properties - The Microsoft Teams channel query properties.
+     * @param teamId - The team ID.
+     * @returns The Microsoft Teams channels.
+     */
     async queryMicrosoftTeamsChannels(properties, teamId) {
         return this.queryAndCheckError(Documents.QueryMicrosoftTeamsChannels, {
             properties: properties,
             teamId: teamId,
         });
     }
+    /**
+     * Queries Discord guilds (servers).
+     * @param properties - The Discord guild query properties.
+     * @returns The Discord guilds.
+     */
     async queryDiscordGuilds(properties) {
         return this.queryAndCheckError(Documents.QueryDiscordGuilds, { properties: properties });
     }
+    /**
+     * Queries Discord channels.
+     * @param properties - The Discord channel query properties.
+     * @returns The Discord channels.
+     */
     async queryDiscordChannels(properties) {
         return this.queryAndCheckError(Documents.QueryDiscordChannels, { properties: properties });
     }
+    /**
+     * Queries Slack channels.
+     * @param properties - The Slack channel query properties.
+     * @returns The Slack channels.
+     */
     async querySlackChannels(properties) {
         return this.queryAndCheckError(Documents.QuerySlackChannels, { properties: properties });
     }
+    /**
+     * Queries Linear projects.
+     * @param properties - The Linear project query properties.
+     * @returns The Linear projects.
+     */
     async queryLinearProjects(properties) {
         return this.queryAndCheckError(Documents.QueryLinearProjects, { properties: properties });
     }
+    /**
+     * Queries GitHub repositories.
+     * @param properties - The GitHub repository query properties.
+     * @param sortBy - The sort order, optional.
+     * @returns The GitHub repositories.
+     */
     async queryGitHubRepositories(properties, sortBy) {
         return this.queryAndCheckError(Documents.QueryGitHubRepositories, {
             properties: properties,
             sortBy: sortBy,
         });
     }
+    /**
+     * Queries Notion databases.
+     * @param properties - The Notion database query properties.
+     * @returns The Notion databases.
+     */
     async queryNotionDatabases(properties) {
         return this.queryAndCheckError(Documents.QueryNotionDatabases, { properties: properties });
     }
+    /**
+     * Queries Notion pages.
+     * @param properties - The Notion page query properties.
+     * @param identifier - The Notion database or page identifier.
+     * @returns The Notion pages.
+     */
     async queryNotionPages(properties, identifier) {
         return this.queryAndCheckError(Documents.QueryNotionPages, {
             properties: properties,
             identifier: identifier,
         });
     }
+    /**
+     * Creates a feed.
+     * @param feed - The feed to create.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The created feed.
+     */
     async createFeed(feed, correlationId) {
         return this.mutateAndCheckError(Documents.CreateFeed, { feed: feed, correlationId: correlationId });
     }
+    /**
+     * Updates a feed.
+     * @param feed - The feed to update.
+     * @returns The updated feed.
+     */
     async updateFeed(feed) {
         return this.mutateAndCheckError(Documents.UpdateFeed, { feed: feed });
     }
+    /**
+     * Deletes a feed.
+     * @param id - The ID of the feed to delete.
+     * @returns The deleted feed.
+     */
     async deleteFeed(id) {
         return this.mutateAndCheckError(Documents.DeleteFeed, { id: id });
     }
+    /**
+     * Deletes multiple feeds.
+     * @param ids - The IDs of the feeds to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted feeds.
+     */
     async deleteFeeds(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteFeeds, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllFeeds(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllFeeds, {
             filter: filter,
@@ -1073,51 +1844,130 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Triggers a feed to run immediately.
+     * @param id - The ID of the feed to trigger.
+     * @returns The triggered feed.
+     */
     async triggerFeed(id) {
         return this.mutateAndCheckError(Documents.TriggerFeed, { id: id });
     }
+    /**
+     * Enables a feed.
+     * @param id - The ID of the feed to enable.
+     * @returns The enabled feed.
+     */
     async enableFeed(id) {
         return this.mutateAndCheckError(Documents.EnableFeed, { id: id });
     }
+    /**
+     * Disables a feed.
+     * @param id - The ID of the feed to disable.
+     * @returns The disabled feed.
+     */
     async disableFeed(id) {
         return this.mutateAndCheckError(Documents.DisableFeed, { id: id });
     }
+    /**
+     * Lookup a feed given its ID.
+     * @param id - ID of the feed.
+     * @returns The feed.
+     */
     async getFeed(id) {
         return this.queryAndCheckError(Documents.GetFeed, { id: id });
     }
+    /**
+     * Retrieves feeds based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving feeds.
+     * @returns The feeds.
+     */
     async queryFeeds(filter) {
         return this.queryAndCheckError(Documents.QueryFeeds, { filter: filter });
     }
+    /**
+     * Counts feeds based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting feeds.
+     * @returns The count of feeds.
+     */
     async countFeeds(filter) {
         return this.queryAndCheckError(Documents.CountFeeds, { filter: filter });
     }
+    /**
+     * Checks if a feed exists based on the provided filter criteria.
+     * @param filter - The filter criteria to apply.
+     * @returns Whether the feed exists.
+     */
     async feedExists(filter) {
         return this.queryAndCheckError(Documents.FeedExists, { filter: filter });
     }
+    /**
+     * Checks if feed processing is complete.
+     * @param id - ID of the feed.
+     * @returns Whether the feed is done processing.
+     */
     async isFeedDone(id) {
         return this.queryAndCheckError(Documents.IsFeedDone, { id: id });
     }
+    /**
+     * 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.
+     */
     async promptSpecifications(prompt, ids) {
         return this.mutateAndCheckError(Documents.PromptSpecifications, { prompt: prompt, ids: ids });
     }
+    /**
+     * Creates a specification (LLM configuration).
+     * @param specification - The specification to create.
+     * @returns The created specification.
+     */
     async createSpecification(specification) {
         return this.mutateAndCheckError(Documents.CreateSpecification, { specification: specification });
     }
+    /**
+     * Updates a specification.
+     * @param specification - The specification to update.
+     * @returns The updated specification.
+     */
     async updateSpecification(specification) {
         return this.mutateAndCheckError(Documents.UpdateSpecification, { specification: specification });
     }
+    /**
+     * Creates or updates a specification.
+     * @param specification - The specification to create or update.
+     * @returns The created or updated specification.
+     */
     async upsertSpecification(specification) {
         return this.mutateAndCheckError(Documents.UpsertSpecification, { specification: specification });
     }
+    /**
+     * Deletes a specification.
+     * @param id - The ID of the specification to delete.
+     * @returns The deleted specification.
+     */
     async deleteSpecification(id) {
         return this.mutateAndCheckError(Documents.DeleteSpecification, { id: id });
     }
+    /**
+     * Deletes multiple specifications.
+     * @param ids - The IDs of the specifications to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted specifications.
+     */
     async deleteSpecifications(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteSpecifications, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /**
+     * 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.
+     */
     async deleteAllSpecifications(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllSpecifications, {
             filter: filter,
@@ -1125,24 +1975,59 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup a specification given its ID.
+     * @param id - ID of the specification.
+     * @returns The specification.
+     */
     async getSpecification(id) {
         return this.queryAndCheckError(Documents.GetSpecification, { id: id });
     }
+    /**
+     * Retrieves specifications based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving specifications.
+     * @returns The specifications.
+     */
     async querySpecifications(filter) {
         return this.queryAndCheckError(Documents.QuerySpecifications, { filter: filter });
     }
+    /**
+     * Counts specifications based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting specifications.
+     * @returns The count of specifications.
+     */
     async countSpecifications(filter) {
         return this.queryAndCheckError(Documents.CountSpecifications, { filter: filter });
     }
+    /**
+     * Checks if a specification exists based on the provided filter criteria.
+     * @param filter - The filter criteria to apply.
+     * @returns Whether the specification exists.
+     */
     async specificationExists(filter) {
         return this.queryAndCheckError(Documents.SpecificationExists, { filter: filter });
     }
+    /**
+     * Retrieves available LLM models based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving models.
+     * @returns The available models.
+     */
     async queryModels(filter) {
         return this.queryAndCheckError(Documents.QueryModels, { filter: filter });
     }
+    /**
+     * Creates a connector for external integrations.
+     * @param connector - The connector to create.
+     * @returns The created connector.
+     */
     async createConnector(connector) {
         return this.mutateAndCheckError(Documents.CreateConnector, { connector: connector });
     }
+    /**
+     * Updates a connector.
+     * @param connector - The connector to update.
+     * @returns The updated connector.
+     */
     async updateConnector(connector) {
         return this.mutateAndCheckError(Documents.UpdateConnector, { connector: connector });
     }
@@ -1156,6 +2041,11 @@ class Graphlit {
       >(Documents.UpsertConnector, { connector: connector });
     }
     */
+    /**
+     * Deletes a connector.
+     * @param id - The ID of the connector to delete.
+     * @returns The deleted connector.
+     */
     async deleteConnector(id) {
         return this.mutateAndCheckError(Documents.DeleteConnector, { id: id });
     }
@@ -1189,12 +2079,27 @@ class Graphlit {
       });
     }
     */
+    /**
+     * Lookup a connector given its ID.
+     * @param id - ID of the connector.
+     * @returns The connector.
+     */
     async getConnector(id) {
         return this.queryAndCheckError(Documents.GetConnector, { id: id });
     }
+    /**
+     * Retrieves connectors based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving connectors.
+     * @returns The connectors.
+     */
     async queryConnectors(filter) {
         return this.queryAndCheckError(Documents.QueryConnectors, { filter: filter });
     }
+    /**
+     * Counts connectors based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting connectors.
+     * @returns The count of connectors.
+     */
     async countConnectors(filter) {
         return this.queryAndCheckError(Documents.CountConnectors, { filter: filter });
     }
@@ -1205,21 +2110,54 @@ class Graphlit {
       return this.queryAndCheckError<Types.QueryConnectorsQuery, Types.QueryConnectorsQueryVariables>(Documents.ConnectorExists, { filter: filter });
     }
     */
+    /**
+     * Creates a view for content filtering.
+     * @param view - The view to create.
+     * @returns The created view.
+     */
     async createView(view) {
         return this.mutateAndCheckError(Documents.CreateView, { view: view });
     }
+    /**
+     * Updates a view.
+     * @param view - The view to update.
+     * @returns The updated view.
+     */
     async updateView(view) {
         return this.mutateAndCheckError(Documents.UpdateView, { view: view });
     }
+    /**
+     * Creates or updates a view.
+     * @param view - The view to create or update.
+     * @returns The created or updated view.
+     */
     async upsertView(view) {
         return this.mutateAndCheckError(Documents.UpsertView, { view: view });
     }
+    /**
+     * Deletes a view.
+     * @param id - The ID of the view to delete.
+     * @returns The deleted view.
+     */
     async deleteView(id) {
         return this.mutateAndCheckError(Documents.DeleteView, { id: id });
     }
+    /**
+     * Deletes multiple views.
+     * @param ids - The IDs of the views to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted views.
+     */
     async deleteViews(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteViews, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllViews(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllViews, {
             filter: filter,
@@ -1227,33 +2165,86 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup a view given its ID.
+     * @param id - ID of the view.
+     * @returns The view.
+     */
     async getView(id) {
         return this.queryAndCheckError(Documents.GetView, { id: id });
     }
+    /**
+     * Retrieves views based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving views.
+     * @returns The views.
+     */
     async queryViews(filter) {
         return this.queryAndCheckError(Documents.QueryViews, { filter: filter });
     }
+    /**
+     * Counts views based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting views.
+     * @returns The count of views.
+     */
     async countViews(filter) {
         return this.queryAndCheckError(Documents.CountViews, { filter: filter });
     }
+    /**
+     * Checks if a view exists based on the provided filter criteria.
+     * @param filter - The filter criteria to apply.
+     * @returns Whether the view exists.
+     */
     async viewExists(filter) {
         return this.queryAndCheckError(Documents.ViewExists, { filter: filter });
     }
+    /**
+     * Creates a workflow for content processing.
+     * @param workflow - The workflow to create.
+     * @returns The created workflow.
+     */
     async createWorkflow(workflow) {
         return this.mutateAndCheckError(Documents.CreateWorkflow, { workflow: workflow });
     }
+    /**
+     * Updates a workflow.
+     * @param workflow - The workflow to update.
+     * @returns The updated workflow.
+     */
     async updateWorkflow(workflow) {
         return this.mutateAndCheckError(Documents.UpdateWorkflow, { workflow: workflow });
     }
+    /**
+     * Creates or updates a workflow.
+     * @param workflow - The workflow to create or update.
+     * @returns The created or updated workflow.
+     */
     async upsertWorkflow(workflow) {
         return this.mutateAndCheckError(Documents.UpsertWorkflow, { workflow: workflow });
     }
+    /**
+     * Deletes a workflow.
+     * @param id - The ID of the workflow to delete.
+     * @returns The deleted workflow.
+     */
     async deleteWorkflow(id) {
         return this.mutateAndCheckError(Documents.DeleteWorkflow, { id: id });
     }
+    /**
+     * Deletes multiple workflows.
+     * @param ids - The IDs of the workflows to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted workflows.
+     */
     async deleteWorkflows(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteWorkflows, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllWorkflows(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllWorkflows, {
             filter: filter,
@@ -1261,60 +2252,157 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup a workflow given its ID.
+     * @param id - ID of the workflow.
+     * @returns The workflow.
+     */
     async getWorkflow(id) {
         return this.queryAndCheckError(Documents.GetWorkflow, { id: id });
     }
+    /**
+     * Retrieves workflows based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving workflows.
+     * @returns The workflows.
+     */
     async queryWorkflows(filter) {
         return this.queryAndCheckError(Documents.QueryWorkflows, { filter: filter });
     }
+    /**
+     * Counts workflows based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting workflows.
+     * @returns The count of workflows.
+     */
     async countWorkflows(filter) {
         return this.queryAndCheckError(Documents.CountWorkflows, { filter: filter });
     }
+    /**
+     * Checks if a workflow exists based on the provided filter criteria.
+     * @param filter - The filter criteria to apply.
+     * @returns Whether the workflow exists.
+     */
     async workflowExists(filter) {
         return this.queryAndCheckError(Documents.WorkflowExists, { filter: filter });
     }
+    /**
+     * Creates a user.
+     * @param user - The user to create.
+     * @returns The created user.
+     */
     async createUser(user) {
         return this.mutateAndCheckError(Documents.CreateUser, { user: user });
     }
+    /**
+     * Updates a user.
+     * @param user - The user to update.
+     * @returns The updated user.
+     */
     async updateUser(user) {
         return this.mutateAndCheckError(Documents.UpdateUser, { user: user });
     }
+    /**
+     * Deletes a user.
+     * @param id - The ID of the user to delete.
+     * @returns The deleted user.
+     */
     async deleteUser(id) {
         return this.mutateAndCheckError(Documents.DeleteUser, { id: id });
     }
+    /**
+     * Lookup a user by their external identifier.
+     * @param identifier - The external identifier.
+     * @returns The user.
+     */
     async getUserByIdentifier(identifier) {
         return this.queryAndCheckError(Documents.GetUserByIdentifier, { identifier: identifier });
     }
+    /**
+     * Gets the current authenticated user.
+     * @returns The current user.
+     */
     async getUser() {
         return this.queryAndCheckError(Documents.GetUser, {});
     }
+    /**
+     * Retrieves users based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving users.
+     * @returns The users.
+     */
     async queryUsers(filter) {
         return this.queryAndCheckError(Documents.QueryUsers, { filter: filter });
     }
+    /**
+     * Counts users based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting users.
+     * @returns The count of users.
+     */
     async countUsers(filter) {
         return this.queryAndCheckError(Documents.CountUsers, { filter: filter });
     }
+    /**
+     * Enables a user.
+     * @param id - The ID of the user to enable.
+     * @returns The enabled user.
+     */
     async enableUser(id) {
         return this.mutateAndCheckError(Documents.EnableUser, { id: id });
     }
+    /**
+     * Disables a user.
+     * @param id - The ID of the user to disable.
+     * @returns The disabled user.
+     */
     async disableUser(id) {
         return this.mutateAndCheckError(Documents.DisableUser, { id: id });
     }
+    /**
+     * Creates a category for content classification.
+     * @param category - The category to create.
+     * @returns The created category.
+     */
     async createCategory(category) {
         return this.mutateAndCheckError(Documents.CreateCategory, { category: category });
     }
+    /**
+     * Updates a category.
+     * @param category - The category to update.
+     * @returns The updated category.
+     */
     async updateCategory(category) {
         return this.mutateAndCheckError(Documents.UpdateCategory, { category: category });
     }
+    /**
+     * Creates or updates a category.
+     * @param category - The category to create or update.
+     * @returns The created or updated category.
+     */
     async upsertCategory(category) {
         return this.mutateAndCheckError(Documents.UpsertCategory, { category: category });
     }
+    /**
+     * Deletes a category.
+     * @param id - The ID of the category to delete.
+     * @returns The deleted category.
+     */
     async deleteCategory(id) {
         return this.mutateAndCheckError(Documents.DeleteCategory, { id: id });
     }
+    /**
+     * Deletes multiple categories.
+     * @param ids - The IDs of the categories to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted categories.
+     */
     async deleteCategories(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteCategories, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllCategories(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllCategories, {
             filter: filter,
@@ -1322,33 +2410,82 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup a category given its ID.
+     * @param id - ID of the category.
+     * @returns The category.
+     */
     async getCategory(id) {
         return this.queryAndCheckError(Documents.GetCategory, { id: id });
     }
+    /**
+     * Retrieves categories based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving categories.
+     * @returns The categories.
+     */
     async queryCategories(filter) {
         return this.queryAndCheckError(Documents.QueryCategories, { filter: filter });
     }
+    /**
+     * 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.
+     */
     async countCategories(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountCategories, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /**
+     * Creates a label for content tagging.
+     * @param label - The label to create.
+     * @returns The created label.
+     */
     async createLabel(label) {
         return this.mutateAndCheckError(Documents.CreateLabel, { label: label });
     }
+    /**
+     * Updates a label.
+     * @param label - The label to update.
+     * @returns The updated label.
+     */
     async updateLabel(label) {
         return this.mutateAndCheckError(Documents.UpdateLabel, { label: label });
     }
+    /**
+     * Creates or updates a label.
+     * @param label - The label to create or update.
+     * @returns The created or updated label.
+     */
     async upsertLabel(label) {
         return this.mutateAndCheckError(Documents.UpsertLabel, { label: label });
     }
+    /**
+     * Deletes a label.
+     * @param id - The ID of the label to delete.
+     * @returns The deleted label.
+     */
     async deleteLabel(id) {
         return this.mutateAndCheckError(Documents.DeleteLabel, { id: id });
     }
+    /**
+     * Deletes multiple labels.
+     * @param ids - The IDs of the labels to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted labels.
+     */
     async deleteLabels(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteLabels, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllLabels(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllLabels, {
             filter: filter,
@@ -1356,30 +2493,74 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup a label given its ID.
+     * @param id - ID of the label.
+     * @returns The label.
+     */
     async getLabel(id) {
         return this.queryAndCheckError(Documents.GetLabel, { id: id });
     }
+    /**
+     * Retrieves labels based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving labels.
+     * @returns The labels.
+     */
     async queryLabels(filter) {
         return this.queryAndCheckError(Documents.QueryLabels, { filter: filter });
     }
+    /**
+     * 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.
+     */
     async countLabels(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountLabels, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /**
+     * Creates a person entity.
+     * @param person - The person to create.
+     * @returns The created person.
+     */
     async createPerson(person) {
         return this.mutateAndCheckError(Documents.CreatePerson, { person: person });
     }
+    /**
+     * Updates a person entity.
+     * @param person - The person to update.
+     * @returns The updated person.
+     */
     async updatePerson(person) {
         return this.mutateAndCheckError(Documents.UpdatePerson, { person: person });
     }
+    /**
+     * Deletes a person entity.
+     * @param id - The ID of the person to delete.
+     * @returns The deleted person.
+     */
     async deletePerson(id) {
         return this.mutateAndCheckError(Documents.DeletePerson, { id: id });
     }
+    /**
+     * Deletes multiple person entities.
+     * @param ids - The IDs of the persons to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted persons.
+     */
     async deletePersons(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeletePersons, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllPersons(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllPersons, {
             filter: filter,
@@ -1387,12 +2568,30 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup a person given their ID.
+     * @param id - ID of the person.
+     * @returns The person.
+     */
     async getPerson(id) {
         return this.queryAndCheckError(Documents.GetPerson, { id: id });
     }
+    /**
+     * 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.
+     */
     async queryPersons(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryPersons, { filter: filter, correlationId: correlationId });
     }
+    /**
+     * 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.
+     */
     async queryPersonsClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryPersonsClusters, {
             filter: filter,
@@ -1400,18 +2599,37 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async queryPersonsExpanded(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryPersonsExpanded, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async countPersons(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountPersons, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async enrichPersons(connector, filter, correlationId) {
         return this.mutateAndCheckError(Documents.EnrichPersons, {
             connector: connector,
@@ -1419,21 +2637,49 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Creates an organization entity.
+     * @param organization - The organization to create.
+     * @returns The created organization.
+     */
     async createOrganization(organization) {
         return this.mutateAndCheckError(Documents.CreateOrganization, { organization: organization });
     }
+    /**
+     * Updates an organization entity.
+     * @param organization - The organization to update.
+     * @returns The updated organization.
+     */
     async updateOrganization(organization) {
         return this.mutateAndCheckError(Documents.UpdateOrganization, { organization: organization });
     }
+    /**
+     * Deletes an organization entity.
+     * @param id - The ID of the organization to delete.
+     * @returns The deleted organization.
+     */
     async deleteOrganization(id) {
         return this.mutateAndCheckError(Documents.DeleteOrganization, { id: id });
     }
+    /**
+     * Deletes multiple organization entities.
+     * @param ids - The IDs of the organizations to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted organizations.
+     */
     async deleteOrganizations(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteOrganizations, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /**
+     * 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.
+     */
     async deleteAllOrganizations(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllOrganizations, {
             filter: filter,
@@ -1441,12 +2687,30 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup an organization given its ID.
+     * @param id - ID of the organization.
+     * @returns The organization.
+     */
     async getOrganization(id) {
         return this.queryAndCheckError(Documents.GetOrganization, { id: id });
     }
+    /**
+     * 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.
+     */
     async queryOrganizations(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryOrganizations, { filter: filter, correlationId: correlationId });
     }
+    /**
+     * 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.
+     */
     async queryOrganizationsClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryOrganizationsClusters, {
             filter: filter,
@@ -1454,18 +2718,37 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async queryOrganizationsExpanded(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryOrganizationsExpanded, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async countOrganizations(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountOrganizations, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async enrichOrganizations(connector, filter, correlationId) {
         return this.mutateAndCheckError(Documents.EnrichOrganizations, {
             connector: connector,
@@ -1473,18 +2756,46 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Creates a place entity.
+     * @param place - The place to create.
+     * @returns The created place.
+     */
     async createPlace(place) {
         return this.mutateAndCheckError(Documents.CreatePlace, { place: place });
     }
+    /**
+     * Updates a place entity.
+     * @param place - The place to update.
+     * @returns The updated place.
+     */
     async updatePlace(place) {
         return this.mutateAndCheckError(Documents.UpdatePlace, { place: place });
     }
+    /**
+     * Deletes a place entity.
+     * @param id - The ID of the place to delete.
+     * @returns The deleted place.
+     */
     async deletePlace(id) {
         return this.mutateAndCheckError(Documents.DeletePlace, { id: id });
     }
+    /**
+     * Deletes multiple place entities.
+     * @param ids - The IDs of the places to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted places.
+     */
     async deletePlaces(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeletePlaces, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllPlaces(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllPlaces, {
             filter: filter,
@@ -1492,12 +2803,30 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup a place given its ID.
+     * @param id - ID of the place.
+     * @returns The place.
+     */
     async getPlace(id) {
         return this.queryAndCheckError(Documents.GetPlace, { id: id });
     }
+    /**
+     * 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.
+     */
     async queryPlaces(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryPlaces, { filter: filter, correlationId: correlationId });
     }
+    /**
+     * 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.
+     */
     async queryPlacesClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryPlacesClusters, {
             filter: filter,
@@ -1505,12 +2834,25 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async countPlaces(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountPlaces, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async enrichPlaces(connector, filter, correlationId) {
         return this.mutateAndCheckError(Documents.EnrichPlaces, {
             connector: connector,
@@ -1518,18 +2860,46 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Creates an event entity.
+     * @param event - The event to create.
+     * @returns The created event.
+     */
     async createEvent(event) {
         return this.mutateAndCheckError(Documents.CreateEvent, { event: event });
     }
+    /**
+     * Updates an event entity.
+     * @param event - The event to update.
+     * @returns The updated event.
+     */
     async updateEvent(event) {
         return this.mutateAndCheckError(Documents.UpdateEvent, { event: event });
     }
+    /**
+     * Deletes an event entity.
+     * @param id - The ID of the event to delete.
+     * @returns The deleted event.
+     */
     async deleteEvent(id) {
         return this.mutateAndCheckError(Documents.DeleteEvent, { id: id });
     }
+    /**
+     * Deletes multiple event entities.
+     * @param ids - The IDs of the events to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted events.
+     */
     async deleteEvents(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteEvents, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllEvents(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllEvents, {
             filter: filter,
@@ -1537,12 +2907,30 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup an event given its ID.
+     * @param id - ID of the event.
+     * @returns The event.
+     */
     async getEvent(id) {
         return this.queryAndCheckError(Documents.GetEvent, { id: id });
     }
+    /**
+     * 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.
+     */
     async queryEvents(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryEvents, { filter: filter, correlationId: correlationId });
     }
+    /**
+     * 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.
+     */
     async queryEventsClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryEventsClusters, {
             filter: filter,
@@ -1550,24 +2938,58 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async countEvents(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountEvents, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /**
+     * Creates a product entity.
+     * @param product - The product to create.
+     * @returns The created product.
+     */
     async createProduct(product) {
         return this.mutateAndCheckError(Documents.CreateProduct, { product: product });
     }
+    /**
+     * Updates a product entity.
+     * @param product - The product to update.
+     * @returns The updated product.
+     */
     async updateProduct(product) {
         return this.mutateAndCheckError(Documents.UpdateProduct, { product: product });
     }
+    /**
+     * Deletes a product entity.
+     * @param id - The ID of the product to delete.
+     * @returns The deleted product.
+     */
     async deleteProduct(id) {
         return this.mutateAndCheckError(Documents.DeleteProduct, { id: id });
     }
+    /**
+     * Deletes multiple product entities.
+     * @param ids - The IDs of the products to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted products.
+     */
     async deleteProducts(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteProducts, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllProducts(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllProducts, {
             filter: filter,
@@ -1575,12 +2997,30 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup a product given its ID.
+     * @param id - ID of the product.
+     * @returns The product.
+     */
     async getProduct(id) {
         return this.queryAndCheckError(Documents.GetProduct, { id: id });
     }
+    /**
+     * 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.
+     */
     async queryProducts(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryProducts, { filter: filter, correlationId: correlationId });
     }
+    /**
+     * 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.
+     */
     async queryProductsClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryProductsClusters, {
             filter: filter,
@@ -1588,12 +3028,25 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async countProducts(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountProducts, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async enrichProducts(connector, filter, correlationId) {
         return this.mutateAndCheckError(Documents.EnrichProducts, {
             connector: connector,
@@ -1601,18 +3054,46 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Creates a repo (code repository) entity.
+     * @param repo - The repo to create.
+     * @returns The created repo.
+     */
     async createRepo(repo) {
         return this.mutateAndCheckError(Documents.CreateRepo, { repo: repo });
     }
+    /**
+     * Updates a repo entity.
+     * @param repo - The repo to update.
+     * @returns The updated repo.
+     */
     async updateRepo(repo) {
         return this.mutateAndCheckError(Documents.UpdateRepo, { repo: repo });
     }
+    /**
+     * Deletes a repo entity.
+     * @param id - The ID of the repo to delete.
+     * @returns The deleted repo.
+     */
     async deleteRepo(id) {
         return this.mutateAndCheckError(Documents.DeleteRepo, { id: id });
     }
+    /**
+     * Deletes multiple repo entities.
+     * @param ids - The IDs of the repos to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted repos.
+     */
     async deleteRepos(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteRepos, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllRepos(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllRepos, {
             filter: filter,
@@ -1620,12 +3101,30 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup a repo given its ID.
+     * @param id - ID of the repo.
+     * @returns The repo.
+     */
     async getRepo(id) {
         return this.queryAndCheckError(Documents.GetRepo, { id: id });
     }
+    /**
+     * 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.
+     */
     async queryRepos(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryRepos, { filter: filter, correlationId: correlationId });
     }
+    /**
+     * 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.
+     */
     async queryReposClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryReposClusters, {
             filter: filter,
@@ -1633,24 +3132,58 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async countRepos(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountRepos, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /**
+     * Creates a software entity.
+     * @param software - The software to create.
+     * @returns The created software.
+     */
     async createSoftware(software) {
         return this.mutateAndCheckError(Documents.CreateSoftware, { software: software });
     }
+    /**
+     * Updates a software entity.
+     * @param software - The software to update.
+     * @returns The updated software.
+     */
     async updateSoftware(software) {
         return this.mutateAndCheckError(Documents.UpdateSoftware, { software: software });
     }
+    /**
+     * Deletes a software entity.
+     * @param id - The ID of the software to delete.
+     * @returns The deleted software.
+     */
     async deleteSoftware(id) {
         return this.mutateAndCheckError(Documents.DeleteSoftware, { id: id });
     }
+    /**
+     * Deletes multiple software entities.
+     * @param ids - The IDs of the software to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted software.
+     */
     async deleteSoftwares(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteSoftwares, { ids: ids, isSynchronous: isSynchronous });
     }
+    /**
+     * 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.
+     */
     async deleteAllSoftwares(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllSoftwares, {
             filter: filter,
@@ -1658,12 +3191,30 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * Lookup a software given its ID.
+     * @param id - ID of the software.
+     * @returns The software.
+     */
     async getSoftware(id) {
         return this.queryAndCheckError(Documents.GetSoftware, { id: id });
     }
+    /**
+     * 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.
+     */
     async querySoftwares(filter, correlationId) {
         return this.queryAndCheckError(Documents.QuerySoftwares, { filter: filter, correlationId: correlationId });
     }
+    /**
+     * 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.
+     */
     async querySoftwaresClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QuerySoftwaresClusters, {
             filter: filter,
@@ -1671,27 +3222,38 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /**
+     * 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.
+     */
     async countSoftwares(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountSoftwares, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Creates a medical condition entity. */
     async createMedicalCondition(MedicalCondition) {
         return this.mutateAndCheckError(Documents.CreateMedicalCondition, { medicalCondition: MedicalCondition });
     }
+    /** Updates a medical condition entity. */
     async updateMedicalCondition(MedicalCondition) {
         return this.mutateAndCheckError(Documents.UpdateMedicalCondition, { medicalCondition: MedicalCondition });
     }
+    /** Deletes a medical condition entity. */
     async deleteMedicalCondition(id) {
         return this.mutateAndCheckError(Documents.DeleteMedicalCondition, { id: id });
     }
+    /** Deletes multiple medical condition entities. */
     async deleteMedicalConditions(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteMedicalConditions, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /** Deletes all medical conditions based on filter criteria. */
     async deleteAllMedicalConditions(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllMedicalConditions, {
             filter: filter,
@@ -1699,12 +3261,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Lookup a medical condition given its ID. */
     async getMedicalCondition(id) {
         return this.queryAndCheckError(Documents.GetMedicalCondition, { id: id });
     }
+    /** Retrieves medical conditions based on filter criteria. */
     async queryMedicalConditions(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalConditions, { filter: filter, correlationId: correlationId });
     }
+    /** Retrieves medical conditions with clustering information. */
     async queryMedicalConditionsClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalConditionsClusters, {
             filter: filter,
@@ -1712,27 +3277,33 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Counts medical conditions based on filter criteria. */
     async countMedicalConditions(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountMedicalConditions, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Creates a medical guideline entity. */
     async createMedicalGuideline(MedicalGuideline) {
         return this.mutateAndCheckError(Documents.CreateMedicalGuideline, { medicalGuideline: MedicalGuideline });
     }
+    /** Updates a medical guideline entity. */
     async updateMedicalGuideline(MedicalGuideline) {
         return this.mutateAndCheckError(Documents.UpdateMedicalGuideline, { medicalGuideline: MedicalGuideline });
     }
+    /** Deletes a medical guideline entity. */
     async deleteMedicalGuideline(id) {
         return this.mutateAndCheckError(Documents.DeleteMedicalGuideline, { id: id });
     }
+    /** Deletes multiple medical guideline entities. */
     async deleteMedicalGuidelines(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteMedicalGuidelines, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /** Deletes all medical guidelines based on filter criteria. */
     async deleteAllMedicalGuidelines(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllMedicalGuidelines, {
             filter: filter,
@@ -1740,12 +3311,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Lookup a medical guideline given its ID. */
     async getMedicalGuideline(id) {
         return this.queryAndCheckError(Documents.GetMedicalGuideline, { id: id });
     }
+    /** Retrieves medical guidelines based on filter criteria. */
     async queryMedicalGuidelines(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalGuidelines, { filter: filter, correlationId: correlationId });
     }
+    /** Retrieves medical guidelines with clustering information. */
     async queryMedicalGuidelinesClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalGuidelinesClusters, {
             filter: filter,
@@ -1759,18 +3333,23 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Creates a medical drug entity. */
     async createMedicalDrug(MedicalDrug) {
         return this.mutateAndCheckError(Documents.CreateMedicalDrug, { medicalDrug: MedicalDrug });
     }
+    /** Updates a medical drug entity. */
     async updateMedicalDrug(MedicalDrug) {
         return this.mutateAndCheckError(Documents.UpdateMedicalDrug, { medicalDrug: MedicalDrug });
     }
+    /** Deletes a medical drug entity. */
     async deleteMedicalDrug(id) {
         return this.mutateAndCheckError(Documents.DeleteMedicalDrug, { id: id });
     }
+    /** Deletes multiple medical drug entities. */
     async deleteMedicalDrugs(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteMedicalDrugs, { ids: ids, isSynchronous: isSynchronous });
     }
+    /** Deletes all medical drugs based on filter criteria. */
     async deleteAllMedicalDrugs(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllMedicalDrugs, {
             filter: filter,
@@ -1778,12 +3357,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Lookup a medical drug given its ID. */
     async getMedicalDrug(id) {
         return this.queryAndCheckError(Documents.GetMedicalDrug, { id: id });
     }
+    /** Retrieves medical drugs based on filter criteria. */
     async queryMedicalDrugs(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalDrugs, { filter: filter, correlationId: correlationId });
     }
+    /** Retrieves medical drugs with clustering information. */
     async queryMedicalDrugsClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalDrugsClusters, {
             filter: filter,
@@ -1791,31 +3373,37 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Counts medical drugs based on filter criteria. */
     async countMedicalDrugs(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountMedicalDrugs, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Creates a medical indication entity. */
     async createMedicalIndication(MedicalIndication) {
         return this.mutateAndCheckError(Documents.CreateMedicalIndication, {
             medicalIndication: MedicalIndication,
         });
     }
+    /** Updates a medical indication entity. */
     async updateMedicalIndication(MedicalIndication) {
         return this.mutateAndCheckError(Documents.UpdateMedicalIndication, {
             medicalIndication: MedicalIndication,
         });
     }
+    /** Deletes a medical indication entity. */
     async deleteMedicalIndication(id) {
         return this.mutateAndCheckError(Documents.DeleteMedicalIndication, { id: id });
     }
+    /** Deletes multiple medical indication entities. */
     async deleteMedicalIndications(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteMedicalIndications, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /** Deletes all medical indications based on filter criteria. */
     async deleteAllMedicalIndications(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllMedicalIndications, {
             filter: filter,
@@ -1823,12 +3411,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Lookup a medical indication given its ID. */
     async getMedicalIndication(id) {
         return this.queryAndCheckError(Documents.GetMedicalIndication, { id: id });
     }
+    /** Retrieves medical indications based on filter criteria. */
     async queryMedicalIndications(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalIndications, { filter: filter, correlationId: correlationId });
     }
+    /** Retrieves medical indications with clustering information. */
     async queryMedicalIndicationsClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalIndicationsClusters, {
             filter: filter,
@@ -1836,31 +3427,37 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Counts medical indications based on filter criteria. */
     async countMedicalIndications(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountMedicalIndications, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Creates a medical contraindication entity. */
     async createMedicalContraindication(MedicalContraindication) {
         return this.mutateAndCheckError(Documents.CreateMedicalContraindication, {
             medicalContraindication: MedicalContraindication,
         });
     }
+    /** Updates a medical contraindication entity. */
     async updateMedicalContraindication(MedicalContraindication) {
         return this.mutateAndCheckError(Documents.UpdateMedicalContraindication, {
             medicalContraindication: MedicalContraindication,
         });
     }
+    /** Deletes a medical contraindication entity. */
     async deleteMedicalContraindication(id) {
         return this.mutateAndCheckError(Documents.DeleteMedicalContraindication, { id: id });
     }
+    /** Deletes multiple medical contraindication entities. */
     async deleteMedicalContraindications(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteMedicalContraindications, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /** Deletes all medical contraindications based on filter criteria. */
     async deleteAllMedicalContraindications(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllMedicalContraindications, {
             filter: filter,
@@ -1868,12 +3465,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Lookup a medical contraindication given its ID. */
     async getMedicalContraindication(id) {
         return this.queryAndCheckError(Documents.GetMedicalContraindication, { id: id });
     }
+    /** Retrieves medical contraindications based on filter criteria. */
     async queryMedicalContraindications(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalContraindications, { filter: filter, correlationId: correlationId });
     }
+    /** Retrieves medical contraindications with clustering information. */
     async queryMedicalContraindicationsClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalContraindicationsClusters, {
             filter: filter,
@@ -1881,24 +3481,30 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Counts medical contraindications based on filter criteria. */
     async countMedicalContraindications(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountMedicalContraindications, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Creates a medical test entity. */
     async createMedicalTest(MedicalTest) {
         return this.mutateAndCheckError(Documents.CreateMedicalTest, { medicalTest: MedicalTest });
     }
+    /** Updates a medical test entity. */
     async updateMedicalTest(MedicalTest) {
         return this.mutateAndCheckError(Documents.UpdateMedicalTest, { medicalTest: MedicalTest });
     }
+    /** Deletes a medical test entity. */
     async deleteMedicalTest(id) {
         return this.mutateAndCheckError(Documents.DeleteMedicalTest, { id: id });
     }
+    /** Deletes multiple medical test entities. */
     async deleteMedicalTests(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteMedicalTests, { ids: ids, isSynchronous: isSynchronous });
     }
+    /** Deletes all medical tests based on filter criteria. */
     async deleteAllMedicalTests(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllMedicalTests, {
             filter: filter,
@@ -1906,12 +3512,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Lookup a medical test given its ID. */
     async getMedicalTest(id) {
         return this.queryAndCheckError(Documents.GetMedicalTest, { id: id });
     }
+    /** Retrieves medical tests based on filter criteria. */
     async queryMedicalTests(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalTests, { filter: filter, correlationId: correlationId });
     }
+    /** Retrieves medical tests with clustering information. */
     async queryMedicalTestsClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalTestsClusters, {
             filter: filter,
@@ -1919,27 +3528,33 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Counts medical tests based on filter criteria. */
     async countMedicalTests(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountMedicalTests, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Creates a medical device entity. */
     async createMedicalDevice(MedicalDevice) {
         return this.mutateAndCheckError(Documents.CreateMedicalDevice, { medicalDevice: MedicalDevice });
     }
+    /** Updates a medical device entity. */
     async updateMedicalDevice(MedicalDevice) {
         return this.mutateAndCheckError(Documents.UpdateMedicalDevice, { medicalDevice: MedicalDevice });
     }
+    /** Deletes a medical device entity. */
     async deleteMedicalDevice(id) {
         return this.mutateAndCheckError(Documents.DeleteMedicalDevice, { id: id });
     }
+    /** Deletes multiple medical device entities. */
     async deleteMedicalDevices(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteMedicalDevices, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /** Deletes all medical devices based on filter criteria. */
     async deleteAllMedicalDevices(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllMedicalDevices, {
             filter: filter,
@@ -1947,12 +3562,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Lookup a medical device given its ID. */
     async getMedicalDevice(id) {
         return this.queryAndCheckError(Documents.GetMedicalDevice, { id: id });
     }
+    /** Retrieves medical devices based on filter criteria. */
     async queryMedicalDevices(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalDevices, { filter: filter, correlationId: correlationId });
     }
+    /** Retrieves medical devices with clustering information. */
     async queryMedicalDevicesClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalDevicesClusters, {
             filter: filter,
@@ -1960,27 +3578,33 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Counts medical devices based on filter criteria. */
     async countMedicalDevices(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountMedicalDevices, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Creates a medical procedure entity. */
     async createMedicalProcedure(MedicalProcedure) {
         return this.mutateAndCheckError(Documents.CreateMedicalProcedure, { medicalProcedure: MedicalProcedure });
     }
+    /** Updates a medical procedure entity. */
     async updateMedicalProcedure(MedicalProcedure) {
         return this.mutateAndCheckError(Documents.UpdateMedicalProcedure, { medicalProcedure: MedicalProcedure });
     }
+    /** Deletes a medical procedure entity. */
     async deleteMedicalProcedure(id) {
         return this.mutateAndCheckError(Documents.DeleteMedicalProcedure, { id: id });
     }
+    /** Deletes multiple medical procedure entities. */
     async deleteMedicalProcedures(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteMedicalProcedures, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /** Deletes all medical procedures based on filter criteria. */
     async deleteAllMedicalProcedures(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllMedicalProcedures, {
             filter: filter,
@@ -1988,12 +3612,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Lookup a medical procedure given its ID. */
     async getMedicalProcedure(id) {
         return this.queryAndCheckError(Documents.GetMedicalProcedure, { id: id });
     }
+    /** Retrieves medical procedures based on filter criteria. */
     async queryMedicalProcedures(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalProcedures, { filter: filter, correlationId: correlationId });
     }
+    /** Retrieves medical procedures with clustering information. */
     async queryMedicalProceduresClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalProceduresClusters, {
             filter: filter,
@@ -2001,27 +3628,33 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Counts medical procedures based on filter criteria. */
     async countMedicalProcedures(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountMedicalProcedures, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Creates a medical study entity. */
     async createMedicalStudy(MedicalStudy) {
         return this.mutateAndCheckError(Documents.CreateMedicalStudy, { medicalStudy: MedicalStudy });
     }
+    /** Updates a medical study entity. */
     async updateMedicalStudy(MedicalStudy) {
         return this.mutateAndCheckError(Documents.UpdateMedicalStudy, { medicalStudy: MedicalStudy });
     }
+    /** Deletes a medical study entity. */
     async deleteMedicalStudy(id) {
         return this.mutateAndCheckError(Documents.DeleteMedicalStudy, { id: id });
     }
+    /** Deletes multiple medical study entities. */
     async deleteMedicalStudies(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteMedicalStudies, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /** Deletes all medical studies based on filter criteria. */
     async deleteAllMedicalStudies(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllMedicalStudies, {
             filter: filter,
@@ -2029,12 +3662,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Lookup a medical study given its ID. */
     async getMedicalStudy(id) {
         return this.queryAndCheckError(Documents.GetMedicalStudy, { id: id });
     }
+    /** Retrieves medical studies based on filter criteria. */
     async queryMedicalStudies(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalStudies, { filter: filter, correlationId: correlationId });
     }
+    /** Retrieves medical studies with clustering information. */
     async queryMedicalStudiesClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalStudiesClusters, {
             filter: filter,
@@ -2042,27 +3678,33 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Counts medical studies based on filter criteria. */
     async countMedicalStudies(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountMedicalStudies, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Creates a medical drug class entity. */
     async createMedicalDrugClass(MedicalDrugClass) {
         return this.mutateAndCheckError(Documents.CreateMedicalDrugClass, { medicalDrugClass: MedicalDrugClass });
     }
+    /** Updates a medical drug class entity. */
     async updateMedicalDrugClass(MedicalDrugClass) {
         return this.mutateAndCheckError(Documents.UpdateMedicalDrugClass, { medicalDrugClass: MedicalDrugClass });
     }
+    /** Deletes a medical drug class entity. */
     async deleteMedicalDrugClass(id) {
         return this.mutateAndCheckError(Documents.DeleteMedicalDrugClass, { id: id });
     }
+    /** Deletes multiple medical drug class entities. */
     async deleteMedicalDrugClasses(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteMedicalDrugClasses, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /** Deletes all medical drug classes based on filter criteria. */
     async deleteAllMedicalDrugClasses(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllMedicalDrugClasses, {
             filter: filter,
@@ -2070,12 +3712,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Lookup a medical drug class given its ID. */
     async getMedicalDrugClass(id) {
         return this.queryAndCheckError(Documents.GetMedicalDrugClass, { id: id });
     }
+    /** Retrieves medical drug classes based on filter criteria. */
     async queryMedicalDrugClasses(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalDrugClasses, { filter: filter, correlationId: correlationId });
     }
+    /** Retrieves medical drug classes with clustering information. */
     async queryMedicalDrugClassesClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalDrugClassesClusters, {
             filter: filter,
@@ -2083,27 +3728,33 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Counts medical drug classes based on filter criteria. */
     async countMedicalDrugClasses(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountMedicalDrugClasses, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Creates a medical therapy entity. */
     async createMedicalTherapy(MedicalTherapy) {
         return this.mutateAndCheckError(Documents.CreateMedicalTherapy, { medicalTherapy: MedicalTherapy });
     }
+    /** Updates a medical therapy entity. */
     async updateMedicalTherapy(MedicalTherapy) {
         return this.mutateAndCheckError(Documents.UpdateMedicalTherapy, { medicalTherapy: MedicalTherapy });
     }
+    /** Deletes a medical therapy entity. */
     async deleteMedicalTherapy(id) {
         return this.mutateAndCheckError(Documents.DeleteMedicalTherapy, { id: id });
     }
+    /** Deletes multiple medical therapy entities. */
     async deleteMedicalTherapies(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteMedicalTherapies, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /** Deletes all medical therapies based on filter criteria. */
     async deleteAllMedicalTherapies(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllMedicalTherapies, {
             filter: filter,
@@ -2111,12 +3762,15 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Lookup a medical therapy given its ID. */
     async getMedicalTherapy(id) {
         return this.queryAndCheckError(Documents.GetMedicalTherapy, { id: id });
     }
+    /** Retrieves medical therapies based on filter criteria. */
     async queryMedicalTherapies(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalTherapies, { filter: filter, correlationId: correlationId });
     }
+    /** Retrieves medical therapies with clustering information. */
     async queryMedicalTherapiesClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryMedicalTherapiesClusters, {
             filter: filter,
@@ -2124,21 +3778,26 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Counts medical therapies based on filter criteria. */
     async countMedicalTherapies(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountMedicalTherapies, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Creates an observation entity. */
     async createObservation(observation) {
         return this.mutateAndCheckError(Documents.CreateObservation, { observation: observation });
     }
+    /** Updates an observation entity. */
     async updateObservation(observation) {
         return this.mutateAndCheckError(Documents.UpdateObservation, { observation: observation });
     }
+    /** Deletes an observation entity. */
     async deleteObservation(id) {
         return this.mutateAndCheckError(Documents.DeleteObservation, { id: id });
     }
+    /** Matches an observable against candidate entities using AI. */
     async matchEntity(observable, candidates, specification, correlationId) {
         return this.mutateAndCheckError(Documents.MatchEntity, {
             observable: observable,
@@ -2147,6 +3806,7 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Resolves multiple entities of a given type using AI similarity matching. */
     async resolveEntities(type, entities, threshold, specification, correlationId) {
         return this.mutateAndCheckError(Documents.ResolveEntities, {
             type: type,
@@ -2156,6 +3816,7 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Resolves a source entity against a target entity using AI similarity matching. */
     async resolveEntity(type, source, target, specification, correlationId) {
         return this.mutateAndCheckError(Documents.ResolveEntity, {
             type: type,
@@ -2165,21 +3826,26 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Creates an investment entity. */
     async createInvestment(investment) {
         return this.mutateAndCheckError(Documents.CreateInvestment, { investment: investment });
     }
+    /** Updates an investment entity. */
     async updateInvestment(investment) {
         return this.mutateAndCheckError(Documents.UpdateInvestment, { investment: investment });
     }
+    /** Deletes an investment entity. */
     async deleteInvestment(id) {
         return this.mutateAndCheckError(Documents.DeleteInvestment, { id: id });
     }
+    /** Deletes multiple investment entities. */
     async deleteInvestments(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteInvestments, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /** Deletes all investments based on filter criteria. */
     async deleteAllInvestments(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllInvestments, {
             filter: filter,
@@ -2187,21 +3853,26 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Creates an investment fund entity. */
     async createInvestmentFund(investmentFund) {
         return this.mutateAndCheckError(Documents.CreateInvestmentFund, { investmentFund: investmentFund });
     }
+    /** Updates an investment fund entity. */
     async updateInvestmentFund(investmentFund) {
         return this.mutateAndCheckError(Documents.UpdateInvestmentFund, { investmentFund: investmentFund });
     }
+    /** Deletes an investment fund entity. */
     async deleteInvestmentFund(id) {
         return this.mutateAndCheckError(Documents.DeleteInvestmentFund, { id: id });
     }
+    /** Deletes multiple investment fund entities. */
     async deleteInvestmentFunds(ids, isSynchronous) {
         return this.mutateAndCheckError(Documents.DeleteInvestmentFunds, {
             ids: ids,
             isSynchronous: isSynchronous,
         });
     }
+    /** Deletes all investment funds based on filter criteria. */
     async deleteAllInvestmentFunds(filter, isSynchronous, correlationId) {
         return this.mutateAndCheckError(Documents.DeleteAllInvestmentFunds, {
             filter: filter,
@@ -2209,15 +3880,18 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Lookup an investment given its ID. */
     async getInvestment(id, correlationId) {
         return this.queryAndCheckError(Documents.GetInvestment, { id: id, correlationId: correlationId });
     }
+    /** Retrieves investments based on filter criteria. */
     async queryInvestments(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryInvestments, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Retrieves investments with clustering information. */
     async queryInvestmentsClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryInvestmentsClusters, {
             filter: filter,
@@ -2225,27 +3899,32 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Retrieves investments with expanded relationship data. */
     async queryInvestmentsExpanded(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryInvestmentsExpanded, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Counts investments based on filter criteria. */
     async countInvestments(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountInvestments, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Lookup an investment fund given its ID. */
     async getInvestmentFund(id, correlationId) {
         return this.queryAndCheckError(Documents.GetInvestmentFund, { id: id, correlationId: correlationId });
     }
+    /** Retrieves investment funds based on filter criteria. */
     async queryInvestmentFunds(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryInvestmentFunds, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Retrieves investment funds with clustering information. */
     async queryInvestmentFundsClusters(filter, clusters, correlationId) {
         return this.queryAndCheckError(Documents.QueryInvestmentFundsClusters, {
             filter: filter,
@@ -2253,12 +3932,14 @@ class Graphlit {
             correlationId: correlationId,
         });
     }
+    /** Retrieves investment funds with expanded relationship data. */
     async queryInvestmentFundsExpanded(filter, correlationId) {
         return this.queryAndCheckError(Documents.QueryInvestmentFundsExpanded, {
             filter: filter,
             correlationId: correlationId,
         });
     }
+    /** Counts investment funds based on filter criteria. */
     async countInvestmentFunds(filter, correlationId) {
         return this.queryAndCheckError(Documents.CountInvestmentFunds, {
             filter: filter,