graphlit-client 1.0.20250531004 → 1.0.20250610001

package/dist/client.js

@@ -1,56 +1,83 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+import * as jwt from "jsonwebtoken";
+import { ApolloClient, InMemoryCache, createHttpLink, ApolloLink, ApolloError, } from "@apollo/client/core";
+import * as Types from "./generated/graphql-types.js";
+import * as Documents from "./generated/graphql-documents.js";
+import * as dotenv from "dotenv";
+import { getServiceType, } from "./model-mapping.js";
+import { UIEventAdapter } from "./streaming/ui-event-adapter.js";
+import { formatMessagesForOpenAI, formatMessagesForAnthropic, formatMessagesForGoogle, } from "./streaming/llm-formatters.js";
+import { streamWithOpenAI, streamWithAnthropic, streamWithGoogle, } from "./streaming/providers.js";
+// Optional imports for streaming LLM clients
+// These are peer dependencies and may not be installed
+let OpenAI;
+let Anthropic;
+let GoogleGenerativeAI;
+try {
+    OpenAI = require("openai").default || require("openai");
+}
+catch (e) {
+    // OpenAI not installed
+}
+try {
+    Anthropic =
+        require("@anthropic-ai/sdk").default || require("@anthropic-ai/sdk");
+}
+catch (e) {
+    // Anthropic SDK not installed
+}
+try {
+    GoogleGenerativeAI = require("@google/generative-ai").GoogleGenerativeAI;
+}
+catch (e) {
+    // Google Generative AI not installed
+}
+// Provider categorization for streaming capabilities
+const STREAMING_PROVIDERS = {
+    // Native streaming with dedicated SDKs
+    NATIVE: [
+        Types.ModelServiceTypes.OpenAi,
+        Types.ModelServiceTypes.Anthropic,
+        Types.ModelServiceTypes.Google,
+    ],
+    // OpenAI-compatible streaming (use OpenAI SDK)
+    OPENAI_COMPATIBLE: [
+        Types.ModelServiceTypes.Groq,
+        Types.ModelServiceTypes.Cerebras,
+        Types.ModelServiceTypes.Mistral,
+        Types.ModelServiceTypes.Deepseek,
+    ],
+    // May require fallback simulation
+    FALLBACK_CANDIDATES: [
+        Types.ModelServiceTypes.AzureAi,
+        Types.ModelServiceTypes.AzureOpenAi,
+        Types.ModelServiceTypes.Cohere,
+        Types.ModelServiceTypes.Bedrock,
+        Types.ModelServiceTypes.Jina,
+        Types.ModelServiceTypes.Replicate,
+        Types.ModelServiceTypes.Voyage,
+    ],
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Types = exports.Graphlit = void 0;
-const jwt = __importStar(require("jsonwebtoken"));
-const core_1 = require("@apollo/client/core");
-const Documents = __importStar(require("./generated/graphql-documents.js"));
-const dotenv = __importStar(require("dotenv"));
 // Define the Graphlit class
 class Graphlit {
+    client;
+    token;
+    apiUri;
+    organizationId;
+    environmentId;
+    ownerId;
+    userId;
+    jwtSecret;
+    // Streaming client instances (optional - can be provided by user)
+    openaiClient;
+    anthropicClient;
+    googleClient;
     constructor(organizationId, environmentId, jwtSecret, ownerId, userId, apiUri) {
-        this.apiUri = apiUri || "https://data-scus.graphlit.io/api/v1/graphql";
+        this.apiUri =
+            apiUri ||
+                (typeof process !== "undefined"
+                    ? process.env.GRAPHLIT_API_URL
+                    : undefined) ||
+                "https://data-scus.graphlit.io/api/v1/graphql";
         if (typeof process !== "undefined") {
             dotenv.config();
             this.organizationId =
@@ -83,10 +110,10 @@ class Graphlit {
     refreshClient() {
         this.client = undefined;
         this.generateToken();
-        const httpLink = (0, core_1.createHttpLink)({
+        const httpLink = createHttpLink({
             uri: this.apiUri,
         });
-        const authLink = new core_1.ApolloLink((operation, forward) => {
+        const authLink = new ApolloLink((operation, forward) => {
             operation.setContext({
                 headers: {
                     Authorization: this.token ? `Bearer ${this.token}` : "",
@@ -94,9 +121,9 @@ class Graphlit {
             });
             return forward(operation);
         });
-        this.client = new core_1.ApolloClient({
+        this.client = new ApolloClient({
             link: authLink.concat(httpLink),
-            cache: new core_1.InMemoryCache(),
+            cache: new InMemoryCache(),
             defaultOptions: {
                 watchQuery: {
                     errorPolicy: "all",
@@ -113,1790 +140,1814 @@ class Graphlit {
             },
         });
     }
+    /**
+     * Set a custom OpenAI client instance for streaming
+     * @param client - OpenAI client instance (e.g., new OpenAI({ apiKey: "..." }))
+     */
+    setOpenAIClient(client) {
+        this.openaiClient = client;
+    }
+    /**
+     * Set a custom Anthropic client instance for streaming
+     * @param client - Anthropic client instance (e.g., new Anthropic({ apiKey: "..." }))
+     */
+    setAnthropicClient(client) {
+        this.anthropicClient = client;
+    }
+    /**
+     * Set a custom Google Generative AI client instance for streaming
+     * @param client - Google GenerativeAI client instance (e.g., new GoogleGenerativeAI(apiKey))
+     */
+    setGoogleClient(client) {
+        this.googleClient = client;
+    }
     generateToken() {
         if (!this.jwtSecret) {
             throw new Error("Graphlit environment JWT secret is required.");
         }
         const expiration = Math.floor(Date.now() / 1000) + 24 * 60 * 60; // one day from now
         const payload = {
-            "https://graphlit.io/jwt/claims": Object.assign(Object.assign(Object.assign({ "x-graphlit-organization-id": this.organizationId, "x-graphlit-environment-id": this.environmentId }, (this.ownerId && { "x-graphlit-owner-id": this.ownerId })), (this.userId && { "x-graphlit-user-id": this.userId })), { "x-graphlit-role": "Owner" }),
+            "https://graphlit.io/jwt/claims": {
+                "x-graphlit-organization-id": this.organizationId,
+                "x-graphlit-environment-id": this.environmentId,
+                ...(this.ownerId && { "x-graphlit-owner-id": this.ownerId }),
+                ...(this.userId && { "x-graphlit-user-id": this.userId }),
+                "x-graphlit-role": "Owner",
+            },
             exp: expiration,
             iss: "graphlit",
             aud: "https://portal.graphlit.io",
         };
         this.token = jwt.sign(payload, this.jwtSecret, { algorithm: "HS256" });
     }
-    getProject() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetProject, {});
-        });
+    async getProject() {
+        return this.queryAndCheckError(Documents.GetProject, {});
     }
-    updateProject(project) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateProject, { project: project });
-        });
+    async updateProject(project) {
+        return this.mutateAndCheckError(Documents.UpdateProject, { project: project });
     }
-    lookupProjectUsage(correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.LookupUsage, { correlationId: correlationId });
-        });
+    async lookupProjectUsage(correlationId) {
+        return this.queryAndCheckError(Documents.LookupUsage, { correlationId: correlationId });
     }
-    lookupProjectCredits(correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.LookupCredits, { correlationId: correlationId });
-        });
+    async lookupProjectCredits(correlationId) {
+        return this.queryAndCheckError(Documents.LookupCredits, { correlationId: correlationId });
     }
-    queryProjectTokens(startDate, duration) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryTokens, { startDate: startDate, duration: duration });
-        });
+    async queryProjectTokens(startDate, duration) {
+        return this.queryAndCheckError(Documents.QueryTokens, { startDate: startDate, duration: duration });
     }
-    queryProjectUsage(startDate, duration, names, excludedNames, offset, limit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryUsage, {
-                startDate: startDate,
-                duration: duration,
-                names: names,
-                excludedNames: excludedNames,
-                offset: offset,
-                limit: limit,
-            });
+    async queryProjectUsage(startDate, duration, names, excludedNames, offset, limit) {
+        return this.queryAndCheckError(Documents.QueryUsage, {
+            startDate: startDate,
+            duration: duration,
+            names: names,
+            excludedNames: excludedNames,
+            offset: offset,
+            limit: limit,
         });
     }
-    queryProjectCredits(startDate, duration) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryCredits, { startDate: startDate, duration: duration });
-        });
+    async queryProjectCredits(startDate, duration) {
+        return this.queryAndCheckError(Documents.QueryCredits, { startDate: startDate, duration: duration });
     }
-    sendNotification(connector, text, textType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.SendNotification, {
-                connector: connector,
-                text: text,
-                textType: textType,
-            });
+    async sendNotification(connector, text, textType) {
+        return this.mutateAndCheckError(Documents.SendNotification, {
+            connector: connector,
+            text: text,
+            textType: textType,
         });
     }
-    mapWeb(uri, allowedPaths, excludedPaths, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.MapWeb, {
-                uri: uri,
-                allowedPaths: allowedPaths,
-                excludedPaths: excludedPaths,
-                correlationId: correlationId,
-            });
+    async mapWeb(uri, allowedPaths, excludedPaths, correlationId) {
+        return this.queryAndCheckError(Documents.MapWeb, {
+            uri: uri,
+            allowedPaths: allowedPaths,
+            excludedPaths: excludedPaths,
+            correlationId: correlationId,
         });
     }
-    searchWeb(text, service, limit, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.SearchWeb, {
-                text: text,
-                service: service,
-                limit: limit,
-                correlationId: correlationId,
-            });
+    async searchWeb(text, service, limit, correlationId) {
+        return this.queryAndCheckError(Documents.SearchWeb, {
+            text: text,
+            service: service,
+            limit: limit,
+            correlationId: correlationId,
         });
     }
-    createAlert(alert, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateAlert, { alert: alert, correlationId: correlationId });
-        });
+    async createAlert(alert, correlationId) {
+        return this.mutateAndCheckError(Documents.CreateAlert, { alert: alert, correlationId: correlationId });
     }
-    updateAlert(alert) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateAlert, { alert: alert });
-        });
+    async updateAlert(alert) {
+        return this.mutateAndCheckError(Documents.UpdateAlert, { alert: alert });
     }
-    deleteAlert(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAlert, { id: id });
-        });
+    async deleteAlert(id) {
+        return this.mutateAndCheckError(Documents.DeleteAlert, { id: id });
     }
-    deleteAlerts(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAlerts, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async deleteAlerts(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteAlerts, { ids: ids, isSynchronous: isSynchronous });
     }
-    deleteAllAlerts(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllAlerts, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
+    async deleteAllAlerts(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllAlerts, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    enableAlert(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.EnableAlert, { id: id });
-        });
+    async enableAlert(id) {
+        return this.mutateAndCheckError(Documents.EnableAlert, { id: id });
     }
-    disableAlert(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DisableAlert, { id: id });
-        });
+    async disableAlert(id) {
+        return this.mutateAndCheckError(Documents.DisableAlert, { id: id });
     }
-    getAlert(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetAlert, { id: id });
-        });
+    async getAlert(id) {
+        return this.queryAndCheckError(Documents.GetAlert, { id: id });
     }
-    queryAlerts(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryAlerts, { filter: filter });
-        });
+    async queryAlerts(filter) {
+        return this.queryAndCheckError(Documents.QueryAlerts, { filter: filter });
     }
-    countAlerts(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.CountAlerts, { filter: filter });
-        });
+    async countAlerts(filter) {
+        return this.queryAndCheckError(Documents.CountAlerts, { filter: filter });
     }
-    createCollection(collection) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateCollection, { collection: collection });
-        });
+    async createCollection(collection) {
+        return this.mutateAndCheckError(Documents.CreateCollection, { collection: collection });
     }
-    updateCollection(collection) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateCollection, { collection: collection });
-        });
+    async updateCollection(collection) {
+        return this.mutateAndCheckError(Documents.UpdateCollection, { collection: collection });
     }
-    deleteCollection(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteCollection, { id: id });
-        });
+    async deleteCollection(id) {
+        return this.mutateAndCheckError(Documents.DeleteCollection, { id: id });
     }
-    deleteCollections(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteCollections, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async deleteCollections(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteCollections, { ids: ids, isSynchronous: isSynchronous });
     }
-    deleteAllCollections(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllCollections, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
+    async deleteAllCollections(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllCollections, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    addContentsToCollections(contents, collections) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.AddContentsToCollections, {
-                contents: contents,
-                collections: collections,
-            });
+    async addContentsToCollections(contents, collections) {
+        return this.mutateAndCheckError(Documents.AddContentsToCollections, {
+            contents: contents,
+            collections: collections,
         });
     }
-    removeContentsFromCollection(contents, collection) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.RemoveContentsFromCollection, {
-                contents: contents,
-                collection: collection,
-            });
+    async removeContentsFromCollection(contents, collection) {
+        return this.mutateAndCheckError(Documents.RemoveContentsFromCollection, {
+            contents: contents,
+            collection: collection,
         });
     }
-    getCollection(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetCollection, { id: id });
-        });
+    async getCollection(id) {
+        return this.queryAndCheckError(Documents.GetCollection, { id: id });
     }
-    queryCollections(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryCollections, { filter: filter });
-        });
+    async queryCollections(filter) {
+        return this.queryAndCheckError(Documents.QueryCollections, { filter: filter });
     }
-    countCollections(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.CountCollections, { filter: filter });
-        });
+    async countCollections(filter) {
+        return this.queryAndCheckError(Documents.CountCollections, { filter: filter });
     }
-    describeImage(prompt, uri, specification, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DescribeImage, {
-                prompt: prompt,
-                uri: uri,
-                specification: specification,
-                correlationId: correlationId,
-            });
+    async describeImage(prompt, uri, specification, correlationId) {
+        return this.mutateAndCheckError(Documents.DescribeImage, {
+            prompt: prompt,
+            uri: uri,
+            specification: specification,
+            correlationId: correlationId,
         });
     }
-    describeEncodedImage(prompt, mimeType, data, specification, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DescribeEncodedImage, {
-                prompt: prompt,
-                mimeType: mimeType,
-                data: data,
-                specification: specification,
-                correlationId: correlationId,
-            });
+    async describeEncodedImage(prompt, mimeType, data, specification, correlationId) {
+        return this.mutateAndCheckError(Documents.DescribeEncodedImage, {
+            prompt: prompt,
+            mimeType: mimeType,
+            data: data,
+            specification: specification,
+            correlationId: correlationId,
         });
     }
-    screenshotPage(uri, maximumHeight, isSynchronous, workflow, collections, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.ScreenshotPage, {
-                uri: uri,
-                maximumHeight: maximumHeight,
-                isSynchronous: isSynchronous,
-                workflow: workflow,
-                collections: collections,
-                correlationId: correlationId,
-            });
+    async screenshotPage(uri, maximumHeight, isSynchronous, workflow, collections, correlationId) {
+        return this.mutateAndCheckError(Documents.ScreenshotPage, {
+            uri: uri,
+            maximumHeight: maximumHeight,
+            isSynchronous: isSynchronous,
+            workflow: workflow,
+            collections: collections,
+            correlationId: correlationId,
         });
-    }
-    ingestTextBatch(batch, textType, collections, observations, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.IngestTextBatch, {
-                batch: batch,
-                textType: textType,
-                collections: collections,
-                observations: observations,
-                correlationId: correlationId,
-            });
+    }
+    async ingestTextBatch(batch, textType, collections, observations, correlationId) {
+        return this.mutateAndCheckError(Documents.IngestTextBatch, {
+            batch: batch,
+            textType: textType,
+            collections: collections,
+            observations: observations,
+            correlationId: correlationId,
+        });
+    }
+    async ingestBatch(uris, workflow, collections, observations, correlationId) {
+        return this.mutateAndCheckError(Documents.IngestBatch, {
+            uris: uris,
+            workflow: workflow,
+            collections: collections,
+            observations: observations,
+            correlationId: correlationId,
+        });
+    }
+    async ingestUri(uri, name, id, isSynchronous, workflow, collections, observations, correlationId) {
+        return this.mutateAndCheckError(Documents.IngestUri, {
+            uri: uri,
+            name: name,
+            id: id,
+            isSynchronous: isSynchronous,
+            workflow: workflow,
+            collections: collections,
+            observations: observations,
+            correlationId: correlationId,
+        });
+    }
+    async ingestText(text, name, textType, uri, id, isSynchronous, workflow, collections, observations, correlationId) {
+        return this.mutateAndCheckError(Documents.IngestText, {
+            name: name,
+            text: text,
+            textType: textType,
+            uri: uri,
+            id: id,
+            isSynchronous: isSynchronous,
+            workflow: workflow,
+            collections: collections,
+            observations: observations,
+            correlationId: correlationId,
+        });
+    }
+    async ingestMemory(text, name, textType, id, collections, correlationId) {
+        return this.mutateAndCheckError(Documents.IngestMemory, {
+            name: name,
+            text: text,
+            textType: textType,
+            id: id,
+            collections: collections,
+            correlationId: correlationId,
+        });
+    }
+    async ingestEvent(markdown, name, description, eventDate, id, collections, correlationId) {
+        return this.mutateAndCheckError(Documents.IngestEvent, {
+            name: name,
+            markdown: markdown,
+            description: description,
+            eventDate: eventDate,
+            id: id,
+            collections: collections,
+            correlationId: correlationId,
+        });
+    }
+    async ingestEncodedFile(name, data, mimeType, fileCreationDate, fileModifiedDate, id, isSynchronous, workflow, collections, observations, correlationId) {
+        return this.mutateAndCheckError(Documents.IngestEncodedFile, {
+            name: name,
+            data: data,
+            mimeType: mimeType,
+            fileCreationDate: fileCreationDate,
+            fileModifiedDate: fileModifiedDate,
+            id: id,
+            isSynchronous: isSynchronous,
+            workflow: workflow,
+            collections: collections,
+            observations: observations,
+            correlationId: correlationId,
+        });
+    }
+    async updateContent(content) {
+        return this.mutateAndCheckError(Documents.UpdateContent, { content: content });
+    }
+    async deleteContent(id) {
+        return this.mutateAndCheckError(Documents.DeleteContent, { id: id });
+    }
+    async deleteContents(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteContents, { ids: ids, isSynchronous: isSynchronous });
+    }
+    async deleteAllContents(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllContents, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
+        });
+    }
+    async summarizeText(summarization, text, textType, correlationId) {
+        return this.mutateAndCheckError(Documents.SummarizeText, {
+            summarization: summarization,
+            text: text,
+            textType: textType,
+            correlationId: correlationId,
+        });
+    }
+    async summarizeContents(summarizations, filter, correlationId) {
+        return this.mutateAndCheckError(Documents.SummarizeContents, {
+            summarizations: summarizations,
+            filter: filter,
+            correlationId: correlationId,
+        });
+    }
+    async extractText(prompt, text, tools, specification, textType, correlationId) {
+        return this.mutateAndCheckError(Documents.ExtractText, {
+            prompt: prompt,
+            text: text,
+            textType: textType,
+            specification: specification,
+            tools: tools,
+            correlationId: correlationId,
+        });
+    }
+    async extractContents(prompt, tools, specification, filter, correlationId) {
+        return this.mutateAndCheckError(Documents.ExtractContents, {
+            prompt: prompt,
+            filter: filter,
+            specification: specification,
+            tools: tools,
+            correlationId: correlationId,
+        });
+    }
+    async publishContents(publishPrompt, connector, summaryPrompt, summarySpecification, publishSpecification, name, filter, workflow, isSynchronous, includeDetails, correlationId) {
+        return this.mutateAndCheckError(Documents.PublishContents, {
+            summaryPrompt: summaryPrompt,
+            summarySpecification: summarySpecification,
+            connector: connector,
+            publishPrompt: publishPrompt,
+            publishSpecification: publishSpecification,
+            name: name,
+            filter: filter,
+            workflow: workflow,
+            isSynchronous: isSynchronous,
+            includeDetails: includeDetails,
+            correlationId: correlationId,
+        });
+    }
+    async publishText(text, textType, connector, name, workflow, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.PublishText, {
+            text: text,
+            textType: textType,
+            connector: connector,
+            name: name,
+            workflow: workflow,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
+        });
+    }
+    async getContent(id) {
+        return this.queryAndCheckError(Documents.GetContent, { id: id });
+    }
+    async queryContents(filter) {
+        return this.queryAndCheckError(Documents.QueryContents, { filter: filter });
+    }
+    async queryContentsFacets(filter) {
+        return this.queryAndCheckError(Documents.QueryContentsFacets, { filter: filter });
+    }
+    async queryContentsGraph(filter) {
+        return this.queryAndCheckError(Documents.QueryContentsGraph, {
+            filter: filter,
+            graph: {
+            /* return everything */
+            },
         });
     }
-    ingestBatch(uris, workflow, collections, observations, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.IngestBatch, {
-                uris: uris,
-                workflow: workflow,
-                collections: collections,
-                observations: observations,
-                correlationId: correlationId,
-            });
-        });
+    async countContents(filter) {
+        return this.queryAndCheckError(Documents.CountContents, { filter: filter });
     }
-    ingestUri(uri, name, id, isSynchronous, workflow, collections, observations, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.IngestUri, {
-                uri: uri,
-                name: name,
-                id: id,
-                isSynchronous: isSynchronous,
-                workflow: workflow,
-                collections: collections,
-                observations: observations,
-                correlationId: correlationId,
-            });
-        });
+    async isContentDone(id) {
+        return this.queryAndCheckError(Documents.IsContentDone, { id: id });
     }
-    ingestText(text, name, textType, uri, id, isSynchronous, workflow, collections, observations, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.IngestText, {
-                name: name,
-                text: text,
-                textType: textType,
-                uri: uri,
-                id: id,
-                isSynchronous: isSynchronous,
-                workflow: workflow,
-                collections: collections,
-                observations: observations,
-                correlationId: correlationId,
-            });
+    async createConversation(conversation, correlationId) {
+        return this.mutateAndCheckError(Documents.CreateConversation, {
+            conversation: conversation,
+            correlationId: correlationId,
         });
     }
-    ingestMemory(text, name, textType, collections, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.IngestMemory, {
-                name: name,
-                text: text,
-                textType: textType,
-                collections: collections,
-                correlationId: correlationId,
-            });
-        });
+    async updateConversation(conversation) {
+        return this.mutateAndCheckError(Documents.UpdateConversation, { conversation: conversation });
     }
-    ingestEvent(markdown, name, description, eventDate, collections, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.IngestEvent, {
-                name: name,
-                markdown: markdown,
-                description: description,
-                eventDate: eventDate,
-                collections: collections,
-                correlationId: correlationId,
-            });
-        });
+    async deleteConversation(id) {
+        return this.mutateAndCheckError(Documents.DeleteConversation, { id: id });
     }
-    ingestEncodedFile(name, data, mimeType, fileCreationDate, fileModifiedDate, id, isSynchronous, workflow, collections, observations, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.IngestEncodedFile, {
-                name: name,
-                data: data,
-                mimeType: mimeType,
-                fileCreationDate: fileCreationDate,
-                fileModifiedDate: fileModifiedDate,
-                id: id,
-                isSynchronous: isSynchronous,
-                workflow: workflow,
-                collections: collections,
-                observations: observations,
-                correlationId: correlationId,
-            });
+    async deleteConversations(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteConversations, {
+            ids: ids,
+            isSynchronous: isSynchronous,
         });
     }
-    updateContent(content) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateContent, { content: content });
+    async deleteAllConversations(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllConversations, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    deleteContent(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteContent, { id: id });
-        });
+    async clearConversation(id) {
+        return this.mutateAndCheckError(Documents.ClearConversation, { id: id });
     }
-    deleteContents(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteContents, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async closeConversation(id) {
+        return this.mutateAndCheckError(Documents.CloseConversation, { id: id });
     }
-    deleteAllContents(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllContents, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async getConversation(id) {
+        return this.queryAndCheckError(Documents.GetConversation, { id: id });
     }
-    summarizeText(summarization, text, textType, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.SummarizeText, {
-                summarization: summarization,
-                text: text,
-                textType: textType,
-                correlationId: correlationId,
-            });
-        });
+    async queryConversations(filter) {
+        return this.queryAndCheckError(Documents.QueryConversations, { filter: filter });
     }
-    summarizeContents(summarizations, filter, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.SummarizeContents, {
-                summarizations: summarizations,
-                filter: filter,
-                correlationId: correlationId,
-            });
-        });
+    async countConversations(filter) {
+        return this.queryAndCheckError(Documents.CountConversations, { filter: filter });
     }
-    extractText(prompt, text, tools, specification, textType, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.ExtractText, {
-                prompt: prompt,
-                text: text,
-                textType: textType,
-                specification: specification,
-                tools: tools,
-                correlationId: correlationId,
-            });
+    async reviseImage(prompt, uri, id, specification, correlationId) {
+        return this.mutateAndCheckError(Documents.ReviseImage, {
+            prompt: prompt,
+            uri: uri,
+            id: id,
+            specification: specification,
+            correlationId: correlationId,
         });
     }
-    extractContents(prompt, tools, specification, filter, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.ExtractContents, {
-                prompt: prompt,
-                filter: filter,
-                specification: specification,
-                tools: tools,
-                correlationId: correlationId,
-            });
+    async reviseEncodedImage(prompt, mimeType, data, id, specification, correlationId) {
+        return this.mutateAndCheckError(Documents.ReviseEncodedImage, {
+            prompt: prompt,
+            mimeType: mimeType,
+            data: data,
+            id: id,
+            specification: specification,
+            correlationId: correlationId,
         });
     }
-    publishContents(publishPrompt, connector, summaryPrompt, summarySpecification, publishSpecification, name, filter, workflow, isSynchronous, includeDetails, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.PublishContents, {
-                summaryPrompt: summaryPrompt,
-                summarySpecification: summarySpecification,
-                connector: connector,
-                publishPrompt: publishPrompt,
-                publishSpecification: publishSpecification,
-                name: name,
-                filter: filter,
-                workflow: workflow,
-                isSynchronous: isSynchronous,
-                includeDetails: includeDetails,
-                correlationId: correlationId,
-            });
+    async reviseText(prompt, text, id, specification, correlationId) {
+        return this.mutateAndCheckError(Documents.ReviseText, {
+            prompt: prompt,
+            text: text,
+            id: id,
+            specification: specification,
+            correlationId: correlationId,
         });
     }
-    publishText(text, textType, connector, name, workflow, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.PublishText, {
-                text: text,
-                textType: textType,
-                connector: connector,
-                name: name,
-                workflow: workflow,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
+    async reviseContent(prompt, content, id, specification, correlationId) {
+        return this.mutateAndCheckError(Documents.ReviseContent, {
+            prompt: prompt,
+            content: content,
+            id: id,
+            specification: specification,
+            correlationId: correlationId,
         });
     }
-    getContent(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetContent, { id: id });
+    async prompt(prompt, mimeType, data, specification, messages, correlationId) {
+        return this.mutateAndCheckError(Documents.Prompt, {
+            prompt: prompt,
+            mimeType: mimeType,
+            data: data,
+            specification: specification,
+            messages: messages,
+            correlationId: correlationId,
         });
     }
-    queryContents(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryContents, { filter: filter });
+    async retrieveSources(prompt, filter, augmentedFilter, retrievalStrategy, rerankingStrategy, correlationId) {
+        return this.mutateAndCheckError(Documents.RetrieveSources, {
+            prompt: prompt,
+            filter: filter,
+            augmentedFilter: augmentedFilter,
+            retrievalStrategy: retrievalStrategy,
+            rerankingStrategy: rerankingStrategy,
+            correlationId: correlationId,
         });
     }
-    queryContentsFacets(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryContentsFacets, { filter: filter });
+    async formatConversation(prompt, id, specification, tools, includeDetails, correlationId) {
+        return this.mutateAndCheckError(Documents.FormatConversation, {
+            prompt: prompt,
+            id: id,
+            specification: specification,
+            tools: tools,
+            includeDetails: includeDetails,
+            correlationId: correlationId,
         });
     }
-    queryContentsGraph(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryContentsGraph, {
-                filter: filter,
-                graph: {
-                /* return everything */
-                },
-            });
+    async completeConversation(completion, id, correlationId) {
+        return this.mutateAndCheckError(Documents.CompleteConversation, {
+            completion: completion,
+            id: id,
+            correlationId: correlationId,
         });
     }
-    countContents(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.CountContents, { filter: filter });
+    async askGraphlit(prompt, type, id, specification, correlationId) {
+        return this.mutateAndCheckError(Documents.AskGraphlit, {
+            prompt: prompt,
+            type: type,
+            id: id,
+            specification: specification,
+            correlationId: correlationId,
         });
     }
-    isContentDone(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.IsContentDone, { id: id });
+    async promptConversation(prompt, id, specification, mimeType, data, tools, requireTool, includeDetails, correlationId) {
+        return this.mutateAndCheckError(Documents.PromptConversation, {
+            prompt: prompt,
+            id: id,
+            specification: specification,
+            mimeType: mimeType,
+            data: data,
+            tools: tools,
+            requireTool: requireTool,
+            includeDetails: includeDetails,
+            correlationId: correlationId,
         });
     }
-    createConversation(conversation, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateConversation, {
-                conversation: conversation,
-                correlationId: correlationId,
-            });
+    async continueConversation(id, responses, correlationId) {
+        return this.mutateAndCheckError(Documents.ContinueConversation, {
+            id: id,
+            responses: responses,
+            correlationId: correlationId,
         });
     }
-    updateConversation(conversation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateConversation, { conversation: conversation });
+    async publishConversation(id, connector, name, workflow, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.PublishConversation, {
+            id: id,
+            connector: connector,
+            name: name,
+            workflow: workflow,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    deleteConversation(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteConversation, { id: id });
+    async suggestConversation(id, count, correlationId) {
+        return this.mutateAndCheckError(Documents.SuggestConversation, {
+            id: id,
+            count: count,
+            correlationId: correlationId,
         });
     }
-    deleteConversations(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteConversations, {
-                ids: ids,
-                isSynchronous: isSynchronous,
-            });
+    async queryOneDriveFolders(properties, folderId) {
+        return this.queryAndCheckError(Documents.QueryOneDriveFolders, {
+            properties: properties,
+            folderId: folderId,
         });
     }
-    deleteAllConversations(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllConversations, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
+    async querySharePointFolders(properties, libraryId, folderId) {
+        return this.queryAndCheckError(Documents.QuerySharePointFolders, {
+            properties: properties,
+            libraryId: libraryId,
+            folderId: folderId,
         });
     }
-    clearConversation(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.ClearConversation, { id: id });
-        });
+    async querySharePointLibraries(properties) {
+        return this.queryAndCheckError(Documents.QuerySharePointLibraries, { properties: properties });
     }
-    closeConversation(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CloseConversation, { id: id });
-        });
+    async queryMicrosoftTeamsTeams(properties) {
+        return this.queryAndCheckError(Documents.QueryMicrosoftTeamsTeams, { properties: properties });
     }
-    getConversation(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetConversation, { id: id });
+    async queryMicrosoftTeamsChannels(properties, teamId) {
+        return this.queryAndCheckError(Documents.QueryMicrosoftTeamsChannels, {
+            properties: properties,
+            teamId: teamId,
         });
     }
-    queryConversations(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryConversations, { filter: filter });
-        });
+    async querySlackChannels(properties) {
+        return this.queryAndCheckError(Documents.QuerySlackChannels, { properties: properties });
     }
-    countConversations(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.CountConversations, { filter: filter });
-        });
+    async queryLinearProjects(properties) {
+        return this.queryAndCheckError(Documents.QueryLinearProjects, { properties: properties });
     }
-    reviseImage(prompt, uri, id, specification, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.ReviseImage, {
-                prompt: prompt,
-                uri: uri,
-                id: id,
-                specification: specification,
-                correlationId: correlationId,
-            });
-        });
+    async queryNotionDatabases(properties) {
+        return this.queryAndCheckError(Documents.QueryNotionDatabases, { properties: properties });
     }
-    reviseEncodedImage(prompt, mimeType, data, id, specification, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.ReviseEncodedImage, {
-                prompt: prompt,
-                mimeType: mimeType,
-                data: data,
-                id: id,
-                specification: specification,
-                correlationId: correlationId,
-            });
+    async queryNotionPages(properties, identifier) {
+        return this.queryAndCheckError(Documents.QueryNotionPages, {
+            properties: properties,
+            identifier: identifier,
         });
     }
-    reviseText(prompt, text, id, specification, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.ReviseText, {
-                prompt: prompt,
-                text: text,
-                id: id,
-                specification: specification,
-                correlationId: correlationId,
-            });
-        });
+    async createFeed(feed, correlationId) {
+        return this.mutateAndCheckError(Documents.CreateFeed, { feed: feed, correlationId: correlationId });
     }
-    reviseContent(prompt, content, id, specification, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.ReviseContent, {
-                prompt: prompt,
-                content: content,
-                id: id,
-                specification: specification,
-                correlationId: correlationId,
-            });
-        });
+    async updateFeed(feed) {
+        return this.mutateAndCheckError(Documents.UpdateFeed, { feed: feed });
     }
-    prompt(prompt, mimeType, data, specification, messages, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.Prompt, {
-                prompt: prompt,
-                mimeType: mimeType,
-                data: data,
-                specification: specification,
-                messages: messages,
-                correlationId: correlationId,
-            });
-        });
+    async deleteFeed(id) {
+        return this.mutateAndCheckError(Documents.DeleteFeed, { id: id });
     }
-    retrieveSources(prompt, filter, augmentedFilter, retrievalStrategy, rerankingStrategy, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.RetrieveSources, {
-                prompt: prompt,
-                filter: filter,
-                augmentedFilter: augmentedFilter,
-                retrievalStrategy: retrievalStrategy,
-                rerankingStrategy: rerankingStrategy,
-                correlationId: correlationId,
-            });
-        });
+    async deleteFeeds(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteFeeds, { ids: ids, isSynchronous: isSynchronous });
     }
-    formatConversation(prompt, id, specification, includeDetails, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.FormatConversation, {
-                prompt: prompt,
-                id: id,
-                specification: specification,
-                includeDetails: includeDetails,
-                correlationId: correlationId,
-            });
+    async deleteAllFeeds(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllFeeds, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    completeConversation(completion, id, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CompleteConversation, {
-                completion: completion,
-                id: id,
-                correlationId: correlationId,
-            });
-        });
+    async enableFeed(id) {
+        return this.mutateAndCheckError(Documents.EnableFeed, { id: id });
     }
-    askGraphlit(prompt, type, id, specification, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.AskGraphlit, {
-                prompt: prompt,
-                type: type,
-                id: id,
-                specification: specification,
-                correlationId: correlationId,
-            });
-        });
+    async disableFeed(id) {
+        return this.mutateAndCheckError(Documents.DisableFeed, { id: id });
     }
-    promptConversation(prompt, id, specification, mimeType, data, tools, requireTool, includeDetails, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.PromptConversation, {
-                prompt: prompt,
-                id: id,
-                specification: specification,
-                mimeType: mimeType,
-                data: data,
-                tools: tools,
-                requireTool: requireTool,
-                includeDetails: includeDetails,
-                correlationId: correlationId,
-            });
-        });
+    async getFeed(id) {
+        return this.queryAndCheckError(Documents.GetFeed, { id: id });
     }
-    continueConversation(id, responses, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.ContinueConversation, {
-                id: id,
-                responses: responses,
-                correlationId: correlationId,
-            });
-        });
+    async queryFeeds(filter) {
+        return this.queryAndCheckError(Documents.QueryFeeds, { filter: filter });
     }
-    publishConversation(id, connector, name, workflow, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.PublishConversation, {
-                id: id,
-                connector: connector,
-                name: name,
-                workflow: workflow,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async countFeeds(filter) {
+        return this.queryAndCheckError(Documents.CountFeeds, { filter: filter });
     }
-    suggestConversation(id, count, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.SuggestConversation, {
-                id: id,
-                count: count,
-                correlationId: correlationId,
-            });
-        });
+    async feedExists(filter) {
+        return this.queryAndCheckError(Documents.FeedExists, { filter: filter });
     }
-    queryOneDriveFolders(properties, folderId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryOneDriveFolders, {
-                properties: properties,
-                folderId: folderId,
-            });
-        });
+    async isFeedDone(id) {
+        return this.queryAndCheckError(Documents.IsFeedDone, { id: id });
     }
-    querySharePointFolders(properties, libraryId, folderId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QuerySharePointFolders, {
-                properties: properties,
-                libraryId: libraryId,
-                folderId: folderId,
-            });
-        });
+    async promptSpecifications(prompt, ids) {
+        return this.mutateAndCheckError(Documents.PromptSpecifications, { prompt: prompt, ids: ids });
     }
-    querySharePointLibraries(properties) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QuerySharePointLibraries, { properties: properties });
-        });
+    async createSpecification(specification) {
+        return this.mutateAndCheckError(Documents.CreateSpecification, { specification: specification });
     }
-    queryMicrosoftTeamsTeams(properties) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMicrosoftTeamsTeams, { properties: properties });
-        });
+    async updateSpecification(specification) {
+        return this.mutateAndCheckError(Documents.UpdateSpecification, { specification: specification });
     }
-    queryMicrosoftTeamsChannels(properties, teamId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMicrosoftTeamsChannels, {
-                properties: properties,
-                teamId: teamId,
-            });
-        });
+    async upsertSpecification(specification) {
+        return this.mutateAndCheckError(Documents.UpsertSpecification, { specification: specification });
     }
-    querySlackChannels(properties) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QuerySlackChannels, { properties: properties });
-        });
+    async deleteSpecification(id) {
+        return this.mutateAndCheckError(Documents.DeleteSpecification, { id: id });
     }
-    queryLinearProjects(properties) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryLinearProjects, { properties: properties });
+    async deleteSpecifications(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteSpecifications, {
+            ids: ids,
+            isSynchronous: isSynchronous,
         });
     }
-    queryNotionDatabases(properties) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryNotionDatabases, { properties: properties });
+    async deleteAllSpecifications(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllSpecifications, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    queryNotionPages(properties, identifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryNotionPages, {
-                properties: properties,
-                identifier: identifier,
-            });
-        });
+    async getSpecification(id) {
+        return this.queryAndCheckError(Documents.GetSpecification, { id: id });
     }
-    createFeed(feed, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateFeed, { feed: feed, correlationId: correlationId });
-        });
+    async querySpecifications(filter) {
+        return this.queryAndCheckError(Documents.QuerySpecifications, { filter: filter });
     }
-    updateFeed(feed) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateFeed, { feed: feed });
-        });
+    async countSpecifications(filter) {
+        return this.queryAndCheckError(Documents.CountSpecifications, { filter: filter });
     }
-    deleteFeed(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteFeed, { id: id });
-        });
+    async specificationExists(filter) {
+        return this.queryAndCheckError(Documents.SpecificationExists, { filter: filter });
     }
-    deleteFeeds(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteFeeds, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async queryModels(filter) {
+        return this.queryAndCheckError(Documents.QueryModels, { filter: filter });
     }
-    deleteAllFeeds(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllFeeds, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async createWorkflow(workflow) {
+        return this.mutateAndCheckError(Documents.CreateWorkflow, { workflow: workflow });
     }
-    enableFeed(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.EnableFeed, { id: id });
-        });
+    async updateWorkflow(workflow) {
+        return this.mutateAndCheckError(Documents.UpdateWorkflow, { workflow: workflow });
     }
-    disableFeed(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DisableFeed, { id: id });
-        });
+    async upsertWorkflow(workflow) {
+        return this.mutateAndCheckError(Documents.UpsertWorkflow, { workflow: workflow });
     }
-    getFeed(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetFeed, { id: id });
-        });
+    async deleteWorkflow(id) {
+        return this.mutateAndCheckError(Documents.DeleteWorkflow, { id: id });
     }
-    queryFeeds(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryFeeds, { filter: filter });
-        });
+    async deleteWorkflows(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteWorkflows, { ids: ids, isSynchronous: isSynchronous });
     }
-    countFeeds(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.CountFeeds, { filter: filter });
+    async deleteAllWorkflows(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllWorkflows, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    feedExists(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.FeedExists, { filter: filter });
-        });
+    async getWorkflow(id) {
+        return this.queryAndCheckError(Documents.GetWorkflow, { id: id });
     }
-    isFeedDone(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.IsFeedDone, { id: id });
-        });
+    async queryWorkflows(filter) {
+        return this.queryAndCheckError(Documents.QueryWorkflows, { filter: filter });
     }
-    promptSpecifications(prompt, ids) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.PromptSpecifications, { prompt: prompt, ids: ids });
-        });
+    async countWorkflows(filter) {
+        return this.queryAndCheckError(Documents.CountWorkflows, { filter: filter });
     }
-    createSpecification(specification) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateSpecification, { specification: specification });
-        });
+    async workflowExists(filter) {
+        return this.queryAndCheckError(Documents.WorkflowExists, { filter: filter });
     }
-    updateSpecification(specification) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateSpecification, { specification: specification });
-        });
+    async createUser(user) {
+        return this.mutateAndCheckError(Documents.CreateUser, { user: user });
     }
-    upsertSpecification(specification) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpsertSpecification, { specification: specification });
-        });
+    async updateUser(user) {
+        return this.mutateAndCheckError(Documents.UpdateUser, { user: user });
     }
-    deleteSpecification(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteSpecification, { id: id });
-        });
+    async deleteUser(id) {
+        return this.mutateAndCheckError(Documents.DeleteUser, { id: id });
     }
-    deleteSpecifications(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteSpecifications, {
-                ids: ids,
-                isSynchronous: isSynchronous,
-            });
-        });
+    async getUser() {
+        return this.queryAndCheckError(Documents.GetUser, {});
     }
-    deleteAllSpecifications(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllSpecifications, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async queryUsers(filter) {
+        return this.queryAndCheckError(Documents.QueryUsers, { filter: filter });
     }
-    getSpecification(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetSpecification, { id: id });
-        });
+    async countUsers(filter) {
+        return this.queryAndCheckError(Documents.CountUsers, { filter: filter });
     }
-    querySpecifications(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QuerySpecifications, { filter: filter });
-        });
+    async enableUser(id) {
+        return this.mutateAndCheckError(Documents.EnableUser, { id: id });
     }
-    countSpecifications(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.CountSpecifications, { filter: filter });
-        });
+    async disableUser(id) {
+        return this.mutateAndCheckError(Documents.DisableUser, { id: id });
     }
-    specificationExists(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.SpecificationExists, { filter: filter });
-        });
+    async createCategory(category) {
+        return this.mutateAndCheckError(Documents.CreateCategory, { category: category });
     }
-    queryModels(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryModels, { filter: filter });
-        });
+    async updateCategory(category) {
+        return this.mutateAndCheckError(Documents.UpdateCategory, { category: category });
     }
-    createWorkflow(workflow) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateWorkflow, { workflow: workflow });
-        });
+    async upsertCategory(category) {
+        return this.mutateAndCheckError(Documents.UpsertCategory, { category: category });
     }
-    updateWorkflow(workflow) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateWorkflow, { workflow: workflow });
-        });
+    async deleteCategory(id) {
+        return this.mutateAndCheckError(Documents.DeleteCategory, { id: id });
     }
-    upsertWorkflow(workflow) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpsertWorkflow, { workflow: workflow });
-        });
+    async deleteCategories(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteCategories, { ids: ids, isSynchronous: isSynchronous });
     }
-    deleteWorkflow(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteWorkflow, { id: id });
+    async deleteAllCategories(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllCategories, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    deleteWorkflows(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteWorkflows, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async getCategory(id) {
+        return this.queryAndCheckError(Documents.GetCategory, { id: id });
     }
-    deleteAllWorkflows(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllWorkflows, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async queryCategories(filter) {
+        return this.queryAndCheckError(Documents.QueryCategories, { filter: filter });
     }
-    getWorkflow(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetWorkflow, { id: id });
-        });
+    async createLabel(label) {
+        return this.mutateAndCheckError(Documents.CreateLabel, { label: label });
     }
-    queryWorkflows(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryWorkflows, { filter: filter });
-        });
+    async updateLabel(label) {
+        return this.mutateAndCheckError(Documents.UpdateLabel, { label: label });
     }
-    countWorkflows(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.CountWorkflows, { filter: filter });
-        });
+    async upsertLabel(label) {
+        return this.mutateAndCheckError(Documents.UpsertLabel, { label: label });
     }
-    workflowExists(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.WorkflowExists, { filter: filter });
-        });
+    async deleteLabel(id) {
+        return this.mutateAndCheckError(Documents.DeleteLabel, { id: id });
     }
-    createUser(user) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateUser, { user: user });
-        });
+    async deleteLabels(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteLabels, { ids: ids, isSynchronous: isSynchronous });
     }
-    updateUser(user) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateUser, { user: user });
+    async deleteAllLabels(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllLabels, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    deleteUser(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteUser, { id: id });
-        });
+    async getLabel(id) {
+        return this.queryAndCheckError(Documents.GetLabel, { id: id });
     }
-    getUser() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetUser, {});
-        });
+    async queryLabels(filter) {
+        return this.queryAndCheckError(Documents.QueryLabels, { filter: filter });
     }
-    queryUsers(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryUsers, { filter: filter });
-        });
+    async createPerson(person) {
+        return this.mutateAndCheckError(Documents.CreatePerson, { person: person });
     }
-    countUsers(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.CountUsers, { filter: filter });
-        });
+    async updatePerson(person) {
+        return this.mutateAndCheckError(Documents.UpdatePerson, { person: person });
     }
-    enableUser(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.EnableUser, { id: id });
-        });
+    async deletePerson(id) {
+        return this.mutateAndCheckError(Documents.DeletePerson, { id: id });
     }
-    disableUser(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DisableUser, { id: id });
-        });
+    async deletePersons(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeletePersons, { ids: ids, isSynchronous: isSynchronous });
     }
-    createCategory(category) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateCategory, { category: category });
+    async deleteAllPersons(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllPersons, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    updateCategory(category) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateCategory, { category: category });
-        });
+    async getPerson(id) {
+        return this.queryAndCheckError(Documents.GetPerson, { id: id });
     }
-    upsertCategory(category) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpsertCategory, { category: category });
-        });
+    async queryPersons(filter) {
+        return this.queryAndCheckError(Documents.QueryPersons, { filter: filter });
     }
-    deleteCategory(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteCategory, { id: id });
-        });
+    async createOrganization(organization) {
+        return this.mutateAndCheckError(Documents.CreateOrganization, { organization: organization });
     }
-    deleteCategories(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteCategories, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async updateOrganization(organization) {
+        return this.mutateAndCheckError(Documents.UpdateOrganization, { organization: organization });
     }
-    deleteAllCategories(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllCategories, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async deleteOrganization(id) {
+        return this.mutateAndCheckError(Documents.DeleteOrganization, { id: id });
     }
-    getCategory(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetCategory, { id: id });
+    async deleteOrganizations(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteOrganizations, {
+            ids: ids,
+            isSynchronous: isSynchronous,
         });
     }
-    queryCategories(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryCategories, { filter: filter });
+    async deleteAllOrganizations(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllOrganizations, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    createLabel(label) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateLabel, { label: label });
-        });
+    async getOrganization(id) {
+        return this.queryAndCheckError(Documents.GetOrganization, { id: id });
     }
-    updateLabel(label) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateLabel, { label: label });
-        });
+    async queryOrganizations(filter) {
+        return this.queryAndCheckError(Documents.QueryOrganizations, { filter: filter });
     }
-    upsertLabel(label) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpsertLabel, { label: label });
-        });
+    async createPlace(place) {
+        return this.mutateAndCheckError(Documents.CreatePlace, { place: place });
     }
-    deleteLabel(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteLabel, { id: id });
-        });
+    async updatePlace(place) {
+        return this.mutateAndCheckError(Documents.UpdatePlace, { place: place });
     }
-    deleteLabels(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteLabels, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async deletePlace(id) {
+        return this.mutateAndCheckError(Documents.DeletePlace, { id: id });
     }
-    deleteAllLabels(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllLabels, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async deletePlaces(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeletePlaces, { ids: ids, isSynchronous: isSynchronous });
     }
-    getLabel(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetLabel, { id: id });
+    async deleteAllPlaces(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllPlaces, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    queryLabels(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryLabels, { filter: filter });
-        });
+    async getPlace(id) {
+        return this.queryAndCheckError(Documents.GetPlace, { id: id });
     }
-    createPerson(person) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreatePerson, { person: person });
-        });
+    async queryPlaces(filter) {
+        return this.queryAndCheckError(Documents.QueryPlaces, { filter: filter });
     }
-    updatePerson(person) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdatePerson, { person: person });
-        });
+    async createEvent(event) {
+        return this.mutateAndCheckError(Documents.CreateEvent, { event: event });
     }
-    deletePerson(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeletePerson, { id: id });
-        });
+    async updateEvent(event) {
+        return this.mutateAndCheckError(Documents.UpdateEvent, { event: event });
     }
-    deletePersons(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeletePersons, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async deleteEvent(id) {
+        return this.mutateAndCheckError(Documents.DeleteEvent, { id: id });
     }
-    deleteAllPersons(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllPersons, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async deleteEvents(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteEvents, { ids: ids, isSynchronous: isSynchronous });
     }
-    getPerson(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetPerson, { id: id });
+    async deleteAllEvents(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllEvents, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    queryPersons(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryPersons, { filter: filter });
-        });
+    async getEvent(id) {
+        return this.queryAndCheckError(Documents.GetEvent, { id: id });
     }
-    createOrganization(organization) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateOrganization, { organization: organization });
-        });
+    async queryEvents(filter) {
+        return this.queryAndCheckError(Documents.QueryEvents, { filter: filter });
     }
-    updateOrganization(organization) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateOrganization, { organization: organization });
-        });
+    async createProduct(product) {
+        return this.mutateAndCheckError(Documents.CreateProduct, { product: product });
     }
-    deleteOrganization(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteOrganization, { id: id });
-        });
+    async updateProduct(product) {
+        return this.mutateAndCheckError(Documents.UpdateProduct, { product: product });
     }
-    deleteOrganizations(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteOrganizations, {
-                ids: ids,
-                isSynchronous: isSynchronous,
-            });
-        });
+    async deleteProduct(id) {
+        return this.mutateAndCheckError(Documents.DeleteProduct, { id: id });
     }
-    deleteAllOrganizations(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllOrganizations, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async deleteProducts(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteProducts, { ids: ids, isSynchronous: isSynchronous });
     }
-    getOrganization(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetOrganization, { id: id });
+    async deleteAllProducts(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllProducts, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    queryOrganizations(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryOrganizations, { filter: filter });
-        });
+    async getProduct(id) {
+        return this.queryAndCheckError(Documents.GetProduct, { id: id });
     }
-    createPlace(place) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreatePlace, { place: place });
-        });
+    async queryProducts(filter) {
+        return this.queryAndCheckError(Documents.QueryProducts, { filter: filter });
     }
-    updatePlace(place) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdatePlace, { place: place });
-        });
+    async createRepo(repo) {
+        return this.mutateAndCheckError(Documents.CreateRepo, { repo: repo });
     }
-    deletePlace(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeletePlace, { id: id });
-        });
+    async updateRepo(repo) {
+        return this.mutateAndCheckError(Documents.UpdateRepo, { repo: repo });
     }
-    deletePlaces(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeletePlaces, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async deleteRepo(id) {
+        return this.mutateAndCheckError(Documents.DeleteRepo, { id: id });
     }
-    deleteAllPlaces(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllPlaces, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async deleteRepos(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteRepos, { ids: ids, isSynchronous: isSynchronous });
     }
-    getPlace(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetPlace, { id: id });
+    async deleteAllRepos(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllRepos, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    queryPlaces(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryPlaces, { filter: filter });
-        });
+    async getRepo(id) {
+        return this.queryAndCheckError(Documents.GetRepo, { id: id });
     }
-    createEvent(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateEvent, { event: event });
-        });
+    async queryRepos(filter) {
+        return this.queryAndCheckError(Documents.QueryRepos, { filter: filter });
     }
-    updateEvent(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateEvent, { event: event });
-        });
+    async createSoftware(software) {
+        return this.mutateAndCheckError(Documents.CreateSoftware, { software: software });
     }
-    deleteEvent(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteEvent, { id: id });
-        });
+    async updateSoftware(software) {
+        return this.mutateAndCheckError(Documents.UpdateSoftware, { software: software });
     }
-    deleteEvents(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteEvents, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async deleteSoftware(id) {
+        return this.mutateAndCheckError(Documents.DeleteSoftware, { id: id });
     }
-    deleteAllEvents(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllEvents, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async deleteSoftwares(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteSoftwares, { ids: ids, isSynchronous: isSynchronous });
     }
-    getEvent(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetEvent, { id: id });
+    async deleteAllSoftwares(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllSoftwares, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    queryEvents(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryEvents, { filter: filter });
-        });
+    async getSoftware(id) {
+        return this.queryAndCheckError(Documents.GetSoftware, { id: id });
     }
-    createProduct(product) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateProduct, { product: product });
-        });
+    async querySoftwares(filter) {
+        return this.queryAndCheckError(Documents.QuerySoftwares, { filter: filter });
     }
-    updateProduct(product) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateProduct, { product: product });
-        });
+    async createMedicalCondition(MedicalCondition) {
+        return this.mutateAndCheckError(Documents.CreateMedicalCondition, { MedicalCondition: MedicalCondition });
     }
-    deleteProduct(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteProduct, { id: id });
-        });
+    async updateMedicalCondition(MedicalCondition) {
+        return this.mutateAndCheckError(Documents.UpdateMedicalCondition, { MedicalCondition: MedicalCondition });
     }
-    deleteProducts(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteProducts, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async deleteMedicalCondition(id) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalCondition, { id: id });
     }
-    deleteAllProducts(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllProducts, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
+    async deleteMedicalConditions(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalConditions, {
+            ids: ids,
+            isSynchronous: isSynchronous,
         });
     }
-    getProduct(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetProduct, { id: id });
+    async deleteAllMedicalConditions(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllMedicalConditions, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    queryProducts(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryProducts, { filter: filter });
-        });
+    async getMedicalCondition(id) {
+        return this.queryAndCheckError(Documents.GetMedicalCondition, { id: id });
     }
-    createRepo(repo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateRepo, { repo: repo });
-        });
+    async queryMedicalConditions(filter) {
+        return this.queryAndCheckError(Documents.QueryMedicalConditions, { filter: filter });
     }
-    updateRepo(repo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateRepo, { repo: repo });
-        });
+    async createMedicalGuideline(MedicalGuideline) {
+        return this.mutateAndCheckError(Documents.CreateMedicalGuideline, { MedicalGuideline: MedicalGuideline });
     }
-    deleteRepo(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteRepo, { id: id });
-        });
+    async updateMedicalGuideline(MedicalGuideline) {
+        return this.mutateAndCheckError(Documents.UpdateMedicalGuideline, { MedicalGuideline: MedicalGuideline });
     }
-    deleteRepos(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteRepos, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async deleteMedicalGuideline(id) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalGuideline, { id: id });
     }
-    deleteAllRepos(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllRepos, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
+    async deleteMedicalGuidelines(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalGuidelines, {
+            ids: ids,
+            isSynchronous: isSynchronous,
         });
     }
-    getRepo(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetRepo, { id: id });
+    async deleteAllMedicalGuidelines(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllMedicalGuidelines, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    queryRepos(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryRepos, { filter: filter });
-        });
+    async getMedicalGuideline(id) {
+        return this.queryAndCheckError(Documents.GetMedicalGuideline, { id: id });
     }
-    createSoftware(software) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateSoftware, { software: software });
-        });
-    }
-    updateSoftware(software) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateSoftware, { software: software });
-        });
+    async queryMedicalGuidelines(filter) {
+        return this.queryAndCheckError(Documents.QueryMedicalGuidelines, { filter: filter });
     }
-    deleteSoftware(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteSoftware, { id: id });
-        });
+    async createMedicalDrug(MedicalDrug) {
+        return this.mutateAndCheckError(Documents.CreateMedicalDrug, { MedicalDrug: MedicalDrug });
     }
-    deleteSoftwares(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteSoftwares, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async updateMedicalDrug(MedicalDrug) {
+        return this.mutateAndCheckError(Documents.UpdateMedicalDrug, { MedicalDrug: MedicalDrug });
     }
-    deleteAllSoftwares(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllSoftwares, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async deleteMedicalDrug(id) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalDrug, { id: id });
     }
-    getSoftware(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetSoftware, { id: id });
-        });
+    async deleteMedicalDrugs(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalDrugs, { ids: ids, isSynchronous: isSynchronous });
     }
-    querySoftwares(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QuerySoftwares, { filter: filter });
+    async deleteAllMedicalDrugs(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllMedicalDrugs, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    createMedicalCondition(MedicalCondition) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateMedicalCondition, { MedicalCondition: MedicalCondition });
-        });
+    async getMedicalDrug(id) {
+        return this.queryAndCheckError(Documents.GetMedicalDrug, { id: id });
     }
-    updateMedicalCondition(MedicalCondition) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateMedicalCondition, { MedicalCondition: MedicalCondition });
-        });
+    async queryMedicalDrugs(filter) {
+        return this.queryAndCheckError(Documents.QueryMedicalDrugs, { filter: filter });
     }
-    deleteMedicalCondition(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalCondition, { id: id });
+    async createMedicalIndication(MedicalIndication) {
+        return this.mutateAndCheckError(Documents.CreateMedicalIndication, {
+            MedicalIndication: MedicalIndication,
         });
     }
-    deleteMedicalConditions(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalConditions, {
-                ids: ids,
-                isSynchronous: isSynchronous,
-            });
+    async updateMedicalIndication(MedicalIndication) {
+        return this.mutateAndCheckError(Documents.UpdateMedicalIndication, {
+            MedicalIndication: MedicalIndication,
         });
     }
-    deleteAllMedicalConditions(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalConditions, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async deleteMedicalIndication(id) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalIndication, { id: id });
     }
-    getMedicalCondition(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetMedicalCondition, { id: id });
+    async deleteMedicalIndications(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalIndications, {
+            ids: ids,
+            isSynchronous: isSynchronous,
         });
     }
-    queryMedicalConditions(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMedicalConditions, { filter: filter });
+    async deleteAllMedicalIndications(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllMedicalIndications, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    createMedicalGuideline(MedicalGuideline) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateMedicalGuideline, { MedicalGuideline: MedicalGuideline });
-        });
+    async getMedicalIndication(id) {
+        return this.queryAndCheckError(Documents.GetMedicalIndication, { id: id });
     }
-    updateMedicalGuideline(MedicalGuideline) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateMedicalGuideline, { MedicalGuideline: MedicalGuideline });
-        });
+    async queryMedicalIndications(filter) {
+        return this.queryAndCheckError(Documents.QueryMedicalIndications, { filter: filter });
     }
-    deleteMedicalGuideline(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalGuideline, { id: id });
+    async createMedicalContraindication(MedicalContraindication) {
+        return this.mutateAndCheckError(Documents.CreateMedicalContraindication, {
+            MedicalContraindication: MedicalContraindication,
         });
     }
-    deleteMedicalGuidelines(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalGuidelines, {
-                ids: ids,
-                isSynchronous: isSynchronous,
-            });
+    async updateMedicalContraindication(MedicalContraindication) {
+        return this.mutateAndCheckError(Documents.UpdateMedicalContraindication, {
+            MedicalContraindication: MedicalContraindication,
         });
     }
-    deleteAllMedicalGuidelines(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalGuidelines, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async deleteMedicalContraindication(id) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalContraindication, { id: id });
     }
-    getMedicalGuideline(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetMedicalGuideline, { id: id });
+    async deleteMedicalContraindications(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalContraindications, {
+            ids: ids,
+            isSynchronous: isSynchronous,
         });
     }
-    queryMedicalGuidelines(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMedicalGuidelines, { filter: filter });
+    async deleteAllMedicalContraindications(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllMedicalContraindications, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    createMedicalDrug(MedicalDrug) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateMedicalDrug, { MedicalDrug: MedicalDrug });
-        });
+    async getMedicalContraindication(id) {
+        return this.queryAndCheckError(Documents.GetMedicalContraindication, { id: id });
     }
-    updateMedicalDrug(MedicalDrug) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateMedicalDrug, { MedicalDrug: MedicalDrug });
-        });
-    }
-    deleteMedicalDrug(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalDrug, { id: id });
-        });
-    }
-    deleteMedicalDrugs(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalDrugs, { ids: ids, isSynchronous: isSynchronous });
-        });
-    }
-    deleteAllMedicalDrugs(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalDrugs, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
-    }
-    getMedicalDrug(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetMedicalDrug, { id: id });
-        });
-    }
-    queryMedicalDrugs(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMedicalDrugs, { filter: filter });
-        });
-    }
-    createMedicalIndication(MedicalIndication) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateMedicalIndication, {
-                MedicalIndication: MedicalIndication,
-            });
-        });
-    }
-    updateMedicalIndication(MedicalIndication) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateMedicalIndication, {
-                MedicalIndication: MedicalIndication,
-            });
-        });
-    }
-    deleteMedicalIndication(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalIndication, { id: id });
-        });
-    }
-    deleteMedicalIndications(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalIndications, {
-                ids: ids,
-                isSynchronous: isSynchronous,
-            });
-        });
-    }
-    deleteAllMedicalIndications(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalIndications, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async queryMedicalContraindications(filter) {
+        return this.queryAndCheckError(Documents.QueryMedicalContraindications, { filter: filter });
     }
-    getMedicalIndication(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetMedicalIndication, { id: id });
-        });
+    async createMedicalTest(MedicalTest) {
+        return this.mutateAndCheckError(Documents.CreateMedicalTest, { MedicalTest: MedicalTest });
     }
-    queryMedicalIndications(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMedicalIndications, { filter: filter });
-        });
+    async updateMedicalTest(MedicalTest) {
+        return this.mutateAndCheckError(Documents.UpdateMedicalTest, { MedicalTest: MedicalTest });
     }
-    createMedicalContraindication(MedicalContraindication) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateMedicalContraindication, {
-                MedicalContraindication: MedicalContraindication,
-            });
-        });
+    async deleteMedicalTest(id) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalTest, { id: id });
     }
-    updateMedicalContraindication(MedicalContraindication) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateMedicalContraindication, {
-                MedicalContraindication: MedicalContraindication,
-            });
-        });
+    async deleteMedicalTests(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalTests, { ids: ids, isSynchronous: isSynchronous });
     }
-    deleteMedicalContraindication(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalContraindication, { id: id });
+    async deleteAllMedicalTests(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllMedicalTests, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    deleteMedicalContraindications(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalContraindications, {
-                ids: ids,
-                isSynchronous: isSynchronous,
-            });
-        });
+    async getMedicalTest(id) {
+        return this.queryAndCheckError(Documents.GetMedicalTest, { id: id });
     }
-    deleteAllMedicalContraindications(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalContraindications, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async queryMedicalTests(filter) {
+        return this.queryAndCheckError(Documents.QueryMedicalTests, { filter: filter });
     }
-    getMedicalContraindication(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetMedicalContraindication, { id: id });
-        });
+    async createMedicalDevice(MedicalDevice) {
+        return this.mutateAndCheckError(Documents.CreateMedicalDevice, { MedicalDevice: MedicalDevice });
     }
-    queryMedicalContraindications(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMedicalContraindications, { filter: filter });
-        });
+    async updateMedicalDevice(MedicalDevice) {
+        return this.mutateAndCheckError(Documents.UpdateMedicalDevice, { MedicalDevice: MedicalDevice });
     }
-    createMedicalTest(MedicalTest) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateMedicalTest, { MedicalTest: MedicalTest });
-        });
+    async deleteMedicalDevice(id) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalDevice, { id: id });
     }
-    updateMedicalTest(MedicalTest) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateMedicalTest, { MedicalTest: MedicalTest });
+    async deleteMedicalDevices(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalDevices, {
+            ids: ids,
+            isSynchronous: isSynchronous,
         });
     }
-    deleteMedicalTest(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalTest, { id: id });
+    async deleteAllMedicalDevices(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllMedicalDevices, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    deleteMedicalTests(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalTests, { ids: ids, isSynchronous: isSynchronous });
-        });
+    async getMedicalDevice(id) {
+        return this.queryAndCheckError(Documents.GetMedicalDevice, { id: id });
     }
-    deleteAllMedicalTests(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalTests, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async queryMedicalDevices(filter) {
+        return this.queryAndCheckError(Documents.QueryMedicalDevices, { filter: filter });
     }
-    getMedicalTest(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetMedicalTest, { id: id });
-        });
+    async createMedicalProcedure(MedicalProcedure) {
+        return this.mutateAndCheckError(Documents.CreateMedicalProcedure, { MedicalProcedure: MedicalProcedure });
     }
-    queryMedicalTests(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMedicalTests, { filter: filter });
-        });
+    async updateMedicalProcedure(MedicalProcedure) {
+        return this.mutateAndCheckError(Documents.UpdateMedicalProcedure, { MedicalProcedure: MedicalProcedure });
     }
-    createMedicalDevice(MedicalDevice) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateMedicalDevice, { MedicalDevice: MedicalDevice });
-        });
+    async deleteMedicalProcedure(id) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalProcedure, { id: id });
     }
-    updateMedicalDevice(MedicalDevice) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateMedicalDevice, { MedicalDevice: MedicalDevice });
+    async deleteMedicalProcedures(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalProcedures, {
+            ids: ids,
+            isSynchronous: isSynchronous,
         });
     }
-    deleteMedicalDevice(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalDevice, { id: id });
+    async deleteAllMedicalProcedures(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllMedicalProcedures, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    deleteMedicalDevices(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalDevices, {
-                ids: ids,
-                isSynchronous: isSynchronous,
-            });
-        });
+    async getMedicalProcedure(id) {
+        return this.queryAndCheckError(Documents.GetMedicalProcedure, { id: id });
     }
-    deleteAllMedicalDevices(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalDevices, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async queryMedicalProcedures(filter) {
+        return this.queryAndCheckError(Documents.QueryMedicalProcedures, { filter: filter });
     }
-    getMedicalDevice(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetMedicalDevice, { id: id });
-        });
+    async createMedicalStudy(MedicalStudy) {
+        return this.mutateAndCheckError(Documents.CreateMedicalStudy, { MedicalStudy: MedicalStudy });
     }
-    queryMedicalDevices(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMedicalDevices, { filter: filter });
-        });
+    async updateMedicalStudy(MedicalStudy) {
+        return this.mutateAndCheckError(Documents.UpdateMedicalStudy, { MedicalStudy: MedicalStudy });
     }
-    createMedicalProcedure(MedicalProcedure) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateMedicalProcedure, { MedicalProcedure: MedicalProcedure });
-        });
+    async deleteMedicalStudy(id) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalStudy, { id: id });
     }
-    updateMedicalProcedure(MedicalProcedure) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateMedicalProcedure, { MedicalProcedure: MedicalProcedure });
+    async deleteMedicalStudies(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalStudies, {
+            ids: ids,
+            isSynchronous: isSynchronous,
         });
     }
-    deleteMedicalProcedure(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalProcedure, { id: id });
+    async deleteAllMedicalStudies(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllMedicalStudies, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    deleteMedicalProcedures(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalProcedures, {
-                ids: ids,
-                isSynchronous: isSynchronous,
-            });
-        });
+    async getMedicalStudy(id) {
+        return this.queryAndCheckError(Documents.GetMedicalStudy, { id: id });
     }
-    deleteAllMedicalProcedures(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalProcedures, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async queryMedicalStudies(filter) {
+        return this.queryAndCheckError(Documents.QueryMedicalStudies, { filter: filter });
     }
-    getMedicalProcedure(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetMedicalProcedure, { id: id });
-        });
+    async createMedicalDrugClass(MedicalDrugClass) {
+        return this.mutateAndCheckError(Documents.CreateMedicalDrugClass, { MedicalDrugClass: MedicalDrugClass });
     }
-    queryMedicalProcedures(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMedicalProcedures, { filter: filter });
-        });
+    async updateMedicalDrugClass(MedicalDrugClass) {
+        return this.mutateAndCheckError(Documents.UpdateMedicalDrugClass, { MedicalDrugClass: MedicalDrugClass });
     }
-    createMedicalStudy(MedicalStudy) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateMedicalStudy, { MedicalStudy: MedicalStudy });
-        });
+    async deleteMedicalDrugClass(id) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalDrugClass, { id: id });
     }
-    updateMedicalStudy(MedicalStudy) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateMedicalStudy, { MedicalStudy: MedicalStudy });
+    async deleteMedicalDrugClasses(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalDrugClasses, {
+            ids: ids,
+            isSynchronous: isSynchronous,
         });
     }
-    deleteMedicalStudy(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalStudy, { id: id });
+    async deleteAllMedicalDrugClasses(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllMedicalDrugClasses, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    deleteMedicalStudies(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalStudies, {
-                ids: ids,
-                isSynchronous: isSynchronous,
-            });
-        });
+    async getMedicalDrugClass(id) {
+        return this.queryAndCheckError(Documents.GetMedicalDrugClass, { id: id });
     }
-    deleteAllMedicalStudies(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalStudies, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async queryMedicalDrugClasses(filter) {
+        return this.queryAndCheckError(Documents.QueryMedicalDrugClasses, { filter: filter });
     }
-    getMedicalStudy(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetMedicalStudy, { id: id });
-        });
+    async createMedicalTherapy(MedicalTherapy) {
+        return this.mutateAndCheckError(Documents.CreateMedicalTherapy, { MedicalTherapy: MedicalTherapy });
     }
-    queryMedicalStudies(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMedicalStudies, { filter: filter });
-        });
+    async updateMedicalTherapy(MedicalTherapy) {
+        return this.mutateAndCheckError(Documents.UpdateMedicalTherapy, { MedicalTherapy: MedicalTherapy });
     }
-    createMedicalDrugClass(MedicalDrugClass) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateMedicalDrugClass, { MedicalDrugClass: MedicalDrugClass });
-        });
+    async deleteMedicalTherapy(id) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalTherapy, { id: id });
     }
-    updateMedicalDrugClass(MedicalDrugClass) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateMedicalDrugClass, { MedicalDrugClass: MedicalDrugClass });
+    async deleteMedicalTherapies(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteMedicalTherapies, {
+            ids: ids,
+            isSynchronous: isSynchronous,
         });
     }
-    deleteMedicalDrugClass(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalDrugClass, { id: id });
+    async deleteAllMedicalTherapies(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllMedicalTherapies, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
         });
     }
-    deleteMedicalDrugClasses(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalDrugClasses, {
-                ids: ids,
-                isSynchronous: isSynchronous,
-            });
-        });
+    async getMedicalTherapy(id) {
+        return this.queryAndCheckError(Documents.GetMedicalTherapy, { id: id });
     }
-    deleteAllMedicalDrugClasses(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalDrugClasses, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
-            });
-        });
+    async queryMedicalTherapies(filter) {
+        return this.queryAndCheckError(Documents.QueryMedicalTherapies, { filter: filter });
     }
-    getMedicalDrugClass(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetMedicalDrugClass, { id: id });
-        });
+    async createObservation(observation) {
+        return this.mutateAndCheckError(Documents.CreateObservation, { observation: observation });
     }
-    queryMedicalDrugClasses(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMedicalDrugClasses, { filter: filter });
-        });
+    async updateObservation(observation) {
+        return this.mutateAndCheckError(Documents.UpdateObservation, { observation: observation });
     }
-    createMedicalTherapy(MedicalTherapy) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateMedicalTherapy, { MedicalTherapy: MedicalTherapy });
-        });
+    async deleteObservation(id) {
+        return this.mutateAndCheckError(Documents.DeleteObservation, { id: id });
     }
-    updateMedicalTherapy(MedicalTherapy) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateMedicalTherapy, { MedicalTherapy: MedicalTherapy });
-        });
+    /**
+     * Creates an event handler that supports UI streaming mode
+     * @internal
+     */
+    /**
+     * Check if streaming is supported with the current configuration
+     * @param specification - Optional specification to check compatibility
+     * @returns true if streaming is available, false otherwise
+     */
+    supportsStreaming(specification) {
+        // If we have a full specification, check its service type
+        if (specification && "modelService" in specification) {
+            const serviceType = specification.modelService;
+            switch (serviceType) {
+                case Types.ModelServiceTypes.OpenAi:
+                    return typeof OpenAI !== "undefined";
+                case Types.ModelServiceTypes.Anthropic:
+                    return typeof Anthropic !== "undefined";
+                case Types.ModelServiceTypes.Google:
+                    return typeof GoogleGenerativeAI !== "undefined";
+                default:
+                    return false;
+            }
+        }
+        // If we only have a reference or no specification, check if any client is available
+        const hasOpenAI = typeof OpenAI !== "undefined";
+        const hasAnthropic = typeof Anthropic !== "undefined";
+        const hasGoogle = typeof GoogleGenerativeAI !== "undefined";
+        return hasOpenAI || hasAnthropic || hasGoogle;
+    }
+    /**
+     * Execute an agent with non-streaming response
+     * @param prompt - The user prompt
+     * @param conversationId - Optional conversation ID to continue
+     * @param specification - Optional specification for the LLM
+     * @param tools - Optional tool definitions
+     * @param toolHandlers - Optional tool handler functions
+     * @param options - Agent options
+     * @returns Complete agent result with message and tool calls
+     */
+    async promptAgent(prompt, conversationId, specification, tools, toolHandlers, options, mimeType, data, // base64 encoded
+    correlationId) {
+        const startTime = Date.now();
+        const maxRounds = options?.maxToolRounds || 10;
+        const timeout = options?.timeout || 300000; // 5 minutes default
+        // Create abort controller for timeout
+        const abortController = new AbortController();
+        const timeoutId = setTimeout(() => abortController.abort(), timeout);
+        try {
+            // 1. Ensure conversation exists
+            let actualConversationId = conversationId;
+            if (!actualConversationId) {
+                const createResponse = await this.createConversation({
+                    name: `Agent conversation`,
+                    specification: specification,
+                    tools: tools,
+                }, correlationId);
+                actualConversationId = createResponse.createConversation?.id;
+                if (!actualConversationId) {
+                    throw new Error("Failed to create conversation");
+                }
+            }
+            // 2. Initial prompt
+            const promptResponse = await this.promptConversation(prompt, actualConversationId, specification, mimeType, data, tools, false, // requireTool
+            false, // includeDetails
+            correlationId);
+            let currentMessage = promptResponse.promptConversation?.message;
+            if (!currentMessage) {
+                throw new Error("No message in prompt response");
+            }
+            // 3. Tool calling loop
+            const allToolCalls = [];
+            let rounds = 0;
+            let totalTokens = 0;
+            while (currentMessage.toolCalls?.length &&
+                rounds < maxRounds &&
+                !abortController.signal.aborted) {
+                rounds++;
+                // Execute tools
+                const toolResults = await this.executeToolsForPromptAgent(currentMessage.toolCalls.filter((tc) => tc !== null), toolHandlers || {}, allToolCalls, abortController.signal);
+                if (abortController.signal.aborted) {
+                    throw new Error("Operation timed out");
+                }
+                // Continue conversation
+                const continueResponse = await this.continueConversation(actualConversationId, toolResults, correlationId);
+                currentMessage = continueResponse.continueConversation?.message;
+                if (!currentMessage)
+                    break;
+                // Track token usage
+                if (continueResponse.continueConversation?.message?.tokens) {
+                    totalTokens += continueResponse.continueConversation.message.tokens;
+                }
+            }
+            return {
+                message: currentMessage?.message || "",
+                conversationId: actualConversationId,
+            };
+        }
+        catch (error) {
+            // Return partial result with error
+            const isTimeout = error.message === "Operation timed out";
+            return {
+                message: "",
+                conversationId: conversationId || "",
+                error: {
+                    message: error.message || "Unknown error",
+                    code: error.code || (isTimeout ? "TIMEOUT" : "UNKNOWN"),
+                    recoverable: isTimeout || error.code === "RATE_LIMIT",
+                    details: error.response?.data,
+                },
+            };
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
     }
-    deleteMedicalTherapy(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalTherapy, { id: id });
-        });
+    /**
+     * Execute an agent with streaming response
+     * @param prompt - The user prompt
+     * @param onEvent - Event handler for streaming events
+     * @param conversationId - Optional conversation ID to continue
+     * @param specification - Optional specification for the LLM
+     * @param tools - Optional tool definitions
+     * @param toolHandlers - Optional tool handler functions
+     * @param options - Stream agent options
+     * @throws Error if streaming is not supported
+     */
+    async streamAgent(prompt, onEvent, conversationId, specification, tools, toolHandlers, options, mimeType, data, // base64 encoded
+    correlationId) {
+        const maxRounds = options?.maxToolRounds || 100;
+        const abortSignal = options?.abortSignal;
+        let uiAdapter;
+        // Check if already aborted
+        if (abortSignal?.aborted) {
+            throw new Error("Operation aborted");
+        }
+        try {
+            // Get full specification if needed
+            const fullSpec = specification?.id
+                ? (await this.getSpecification(specification.id))
+                    .specification
+                : undefined;
+            // Check streaming support
+            if (!this.supportsStreaming(fullSpec)) {
+                throw new Error("Streaming is not supported for this specification. " +
+                    "Use promptAgent() instead or configure a streaming client.");
+            }
+            // Ensure conversation
+            let actualConversationId = conversationId;
+            if (!actualConversationId) {
+                const createResponse = await this.createConversation({
+                    name: `Streaming agent conversation`,
+                    specification: specification,
+                    tools: tools,
+                }, correlationId);
+                actualConversationId = createResponse.createConversation?.id;
+                if (!actualConversationId) {
+                    throw new Error("Failed to create conversation");
+                }
+            }
+            // Create UI event adapter
+            uiAdapter = new UIEventAdapter(onEvent, actualConversationId, {
+                showTokenStream: options?.showTokenStream ?? true,
+                smoothingEnabled: options?.smoothingEnabled ?? true,
+                chunkingStrategy: options?.chunkingStrategy ?? "word",
+                smoothingDelay: options?.smoothingDelay ?? 30,
+            });
+            // Start the streaming conversation
+            await this.executeStreamingAgent(prompt, actualConversationId, fullSpec, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Streaming failed";
+            if (uiAdapter) {
+                uiAdapter.handleEvent({
+                    type: "error",
+                    error: errorMessage,
+                });
+            }
+            else {
+                // Fallback error event
+                onEvent({
+                    type: "error",
+                    error: {
+                        message: errorMessage,
+                        recoverable: false,
+                    },
+                    conversationId: conversationId || "",
+                    timestamp: new Date(),
+                });
+            }
+            throw error;
+        }
+        finally {
+            // Clean up adapter
+            if (uiAdapter) {
+                uiAdapter.dispose();
+            }
+        }
     }
-    deleteMedicalTherapies(ids, isSynchronous) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalTherapies, {
-                ids: ids,
-                isSynchronous: isSynchronous,
+    /**
+     * Execute the streaming agent workflow with tool calling loop
+     */
+    async executeStreamingAgent(prompt, conversationId, specification, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId) {
+        let currentRound = 0;
+        let fullMessage = "";
+        // Start the conversation
+        uiAdapter.handleEvent({
+            type: "start",
+            conversationId,
+        });
+        // Format conversation once at the beginning
+        const formatResponse = await this.formatConversation(prompt, conversationId, { id: specification.id }, tools, true, correlationId);
+        const formattedPrompt = formatResponse.formatConversation?.message?.message;
+        if (!formattedPrompt) {
+            throw new Error("Failed to format conversation");
+        }
+        // Build message array with conversation history
+        const messages = [];
+        // Add system prompt if specified
+        if (specification.systemPrompt) {
+            messages.push({
+                __typename: "ConversationMessage",
+                role: Types.ConversationRoleTypes.System,
+                message: specification.systemPrompt,
+                timestamp: new Date().toISOString(),
             });
-        });
-    }
-    deleteAllMedicalTherapies(filter, isSynchronous, correlationId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalTherapies, {
-                filter: filter,
-                isSynchronous: isSynchronous,
-                correlationId: correlationId,
+        }
+        // Get conversation history to maintain context
+        const conversationResponse = await this.getConversation(conversationId);
+        const conversation = conversationResponse.conversation;
+        if (conversation?.messages && conversation.messages.length > 0) {
+            // Add all previous messages (formatConversation already added the current prompt)
+            const previousMessages = conversation.messages;
+            messages.push(...previousMessages);
+        }
+        else {
+            // If no history, just add the current user message
+            messages.push({
+                __typename: "ConversationMessage",
+                role: Types.ConversationRoleTypes.User,
+                message: formattedPrompt,
+                timestamp: new Date().toISOString(),
             });
+        }
+        const serviceType = getServiceType(specification);
+        // Handle tool calling loop locally
+        while (currentRound < maxRounds) {
+            if (abortSignal?.aborted) {
+                throw new Error("Operation aborted");
+            }
+            let toolCalls = [];
+            let roundMessage = "";
+            // Stream with appropriate provider
+            if (serviceType === Types.ModelServiceTypes.OpenAi && OpenAI) {
+                const openaiMessages = formatMessagesForOpenAI(messages);
+                await this.streamWithOpenAI(specification, openaiMessages, tools, uiAdapter, (message, calls) => {
+                    roundMessage = message;
+                    toolCalls = calls;
+                });
+            }
+            else if (serviceType === Types.ModelServiceTypes.Anthropic &&
+                Anthropic) {
+                const { system, messages: anthropicMessages } = formatMessagesForAnthropic(messages);
+                await this.streamWithAnthropic(specification, anthropicMessages, system, tools, uiAdapter, (message, calls) => {
+                    roundMessage = message;
+                    toolCalls = calls;
+                });
+            }
+            else if (serviceType === Types.ModelServiceTypes.Google &&
+                GoogleGenerativeAI) {
+                const googleMessages = formatMessagesForGoogle(messages);
+                // Google doesn't use system prompts separately, they're incorporated into messages
+                await this.streamWithGoogle(specification, googleMessages, undefined, // systemPrompt - Google handles this differently
+                tools, uiAdapter, (message, calls) => {
+                    roundMessage = message;
+                    toolCalls = calls;
+                });
+            }
+            else {
+                // Fallback to non-streaming
+                await this.fallbackToNonStreaming(prompt, conversationId, specification, tools, mimeType, data, uiAdapter, correlationId);
+                break;
+            }
+            // Update the full message
+            fullMessage = roundMessage;
+            // If no tool calls, we're done
+            if (!toolCalls || toolCalls.length === 0) {
+                break;
+            }
+            // Execute tools and prepare for next round
+            if (toolHandlers && toolCalls.length > 0) {
+                // Add assistant message with tool calls to conversation
+                const assistantMessage = {
+                    __typename: "ConversationMessage",
+                    role: Types.ConversationRoleTypes.Assistant,
+                    message: roundMessage,
+                    toolCalls: toolCalls,
+                    timestamp: new Date().toISOString(),
+                };
+                messages.push(assistantMessage);
+                // Execute tools and add responses
+                for (const toolCall of toolCalls) {
+                    const handler = toolHandlers[toolCall.name];
+                    if (!handler) {
+                        console.warn(`No handler for tool: ${toolCall.name}`);
+                        continue;
+                    }
+                    try {
+                        const args = JSON.parse(toolCall.arguments);
+                        // Update UI
+                        uiAdapter.handleEvent({
+                            type: "tool_call_start",
+                            toolCall: {
+                                id: toolCall.id,
+                                name: toolCall.name,
+                            },
+                        });
+                        // Execute tool
+                        const result = await handler(args);
+                        // Update UI
+                        uiAdapter.setToolResult(toolCall.id, result);
+                        // Add tool response to messages
+                        messages.push({
+                            __typename: "ConversationMessage",
+                            role: Types.ConversationRoleTypes.Tool,
+                            message: typeof result === "string" ? result : JSON.stringify(result),
+                            toolCallId: toolCall.id,
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                        console.error(`Tool execution error for ${toolCall.name}:`, error);
+                        // Update UI with error
+                        uiAdapter.setToolResult(toolCall.id, undefined, errorMessage);
+                        // Add error response
+                        messages.push({
+                            __typename: "ConversationMessage",
+                            role: Types.ConversationRoleTypes.Tool,
+                            message: `Error: ${errorMessage}`,
+                            toolCallId: toolCall.id,
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                }
+            }
+            currentRound++;
+        }
+        // Complete the conversation
+        if (fullMessage) {
+            await this.completeConversation(fullMessage.trim(), conversationId, correlationId);
+        }
+        // Emit completion event
+        uiAdapter.handleEvent({
+            type: "complete",
+            conversationId,
+        });
+    }
+    /**
+     * Build message array for LLM from conversation history
+     */
+    async buildMessageArray(conversationId, specification, currentPrompt) {
+        const messages = [];
+        // Add system prompt if present
+        if (specification.systemPrompt) {
+            const systemMessage = {
+                __typename: "ConversationMessage",
+                role: Types.ConversationRoleTypes.System,
+                message: specification.systemPrompt,
+                timestamp: new Date().toISOString(),
+            };
+            messages.push(systemMessage);
+        }
+        // Get conversation history
+        const conversationResponse = await this.getConversation(conversationId);
+        const conversation = conversationResponse.conversation;
+        if (conversation?.messages && conversation.messages.length > 0) {
+            // Add previous messages (excluding the current one)
+            const previousMessages = conversation.messages.slice(0, -1);
+            messages.push(...previousMessages);
+        }
+        // Add current user message
+        const currentMessage = {
+            __typename: "ConversationMessage",
+            role: Types.ConversationRoleTypes.User, // Current prompt is from the user
+            message: currentPrompt,
+            timestamp: new Date().toISOString(),
+        };
+        messages.push(currentMessage);
+        return messages;
+    }
+    /**
+     * Execute tools during streaming with proper event emission
+     */
+    async executeToolsInStream(toolCalls, toolHandlers, uiAdapter, abortSignal) {
+        const toolPromises = toolCalls.map(async (toolCall) => {
+            if (abortSignal?.aborted)
+                return;
+            const handler = toolHandlers[toolCall.name];
+            if (!handler) {
+                uiAdapter.setToolResult(toolCall.id, null, `No handler for tool: ${toolCall.name}`);
+                return;
+            }
+            try {
+                const args = toolCall.arguments ? JSON.parse(toolCall.arguments) : {};
+                const result = await handler(args);
+                uiAdapter.setToolResult(toolCall.id, result);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Tool execution failed";
+                uiAdapter.setToolResult(toolCall.id, null, errorMessage);
+            }
         });
+        await Promise.all(toolPromises);
+    }
+    /**
+     * Format tool results for API
+     */
+    async formatToolResults(toolCalls, toolHandlers) {
+        const results = [];
+        for (const toolCall of toolCalls) {
+            const handler = toolHandlers[toolCall.name];
+            if (handler) {
+                try {
+                    const args = toolCall.arguments ? JSON.parse(toolCall.arguments) : {};
+                    const result = await handler(args);
+                    results.push({
+                        id: toolCall.id,
+                        content: JSON.stringify(result),
+                    });
+                }
+                catch (error) {
+                    results.push({
+                        id: toolCall.id,
+                        content: JSON.stringify({
+                            error: error instanceof Error
+                                ? error.message
+                                : "Tool execution failed",
+                        }),
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Fallback to non-streaming when streaming is not available
+     */
+    async fallbackToNonStreaming(prompt, conversationId, specification, tools, mimeType, data, uiAdapter, correlationId) {
+        const response = await this.promptConversation(prompt, conversationId, { id: specification.id }, mimeType, data, tools, false, false, correlationId);
+        const message = response.promptConversation?.message;
+        if (message?.message) {
+            // Simulate streaming by emitting tokens
+            const words = message.message.split(" ");
+            for (let i = 0; i < words.length; i++) {
+                const token = i === 0 ? words[i] : " " + words[i];
+                uiAdapter.handleEvent({ type: "token", token });
+            }
+            uiAdapter.handleEvent({ type: "message", message: message.message });
+        }
     }
-    getMedicalTherapy(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.GetMedicalTherapy, { id: id });
-        });
-    }
-    queryMedicalTherapies(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.queryAndCheckError(Documents.QueryMedicalTherapies, { filter: filter });
-        });
-    }
-    createObservation(observation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.CreateObservation, { observation: observation });
-        });
-    }
-    updateObservation(observation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.UpdateObservation, { observation: observation });
-        });
-    }
-    deleteObservation(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteObservation, { id: id });
-        });
+    /**
+     * Stream with OpenAI client
+     */
+    async streamWithOpenAI(specification, messages, tools, uiAdapter, onComplete) {
+        if (!OpenAI) {
+            throw new Error("OpenAI client not available");
+        }
+        // Use provided client or create a new one
+        const openaiClient = this.openaiClient ||
+            new OpenAI({
+                apiKey: process.env.OPENAI_API_KEY || "",
+            });
+        await streamWithOpenAI(specification, messages, tools, openaiClient, (event) => uiAdapter.handleEvent(event), onComplete);
+    }
+    /**
+     * Stream with Anthropic client
+     */
+    async streamWithAnthropic(specification, messages, systemPrompt, tools, uiAdapter, onComplete) {
+        if (!Anthropic) {
+            throw new Error("Anthropic client not available");
+        }
+        // Use provided client or create a new one
+        const anthropicClient = this.anthropicClient ||
+            new Anthropic({
+                apiKey: process.env.ANTHROPIC_API_KEY || "",
+            });
+        await streamWithAnthropic(specification, messages, systemPrompt, tools, anthropicClient, (event) => uiAdapter.handleEvent(event), onComplete);
+    }
+    /**
+     * Stream with Google client
+     */
+    async streamWithGoogle(specification, messages, systemPrompt, tools, uiAdapter, onComplete) {
+        if (!GoogleGenerativeAI) {
+            throw new Error("Google GenerativeAI client not available");
+        }
+        // Use provided client or create a new one
+        const googleClient = this.googleClient ||
+            new GoogleGenerativeAI(process.env.GOOGLE_API_KEY || "");
+        await streamWithGoogle(specification, messages, systemPrompt, tools, googleClient, (event) => uiAdapter.handleEvent(event), onComplete);
+    }
+    // Helper method to execute tools for promptAgent
+    async executeToolsForPromptAgent(toolCalls, toolHandlers, allToolCalls, signal) {
+        const responses = [];
+        // Execute tools in parallel for better performance
+        const toolPromises = toolCalls.map(async (toolCall) => {
+            if (!toolCall || signal.aborted)
+                return null;
+            const startTime = Date.now();
+            const handler = toolHandlers[toolCall.name || ""];
+            let result;
+            let error;
+            try {
+                if (!handler) {
+                    throw new Error(`No handler found for tool: ${toolCall.name}`);
+                }
+                const args = toolCall.arguments ? JSON.parse(toolCall.arguments) : {};
+                // Add timeout for individual tool calls (30 seconds)
+                const toolTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Tool execution timeout")), 30000));
+                result = await Promise.race([handler(args), toolTimeout]);
+            }
+            catch (e) {
+                error = e.message || "Tool execution failed";
+                console.error(`Tool ${toolCall.name} failed:`, e);
+            }
+            // Record for result
+            const toolResult = {
+                id: toolCall.id,
+                name: toolCall.name || "",
+                arguments: toolCall.arguments ? JSON.parse(toolCall.arguments) : {},
+                result,
+                error,
+                duration: Date.now() - startTime,
+            };
+            allToolCalls.push(toolResult);
+            // Response for API
+            return {
+                id: toolCall.id,
+                content: error ? error : result ? JSON.stringify(result) : "",
+            };
+        });
+        const results = await Promise.all(toolPromises);
+        return results.filter((r) => r !== null);
     }
     // helper functions
     prettyPrintGraphQLError(err) {
@@ -1915,82 +1966,80 @@ class Graphlit {
         }
         return parts.join(" ");
     }
-    mutateAndCheckError(mutation, variables) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.client === undefined)
-                throw new Error("Apollo Client not configured.");
-            try {
-                const result = yield this.client.mutate({
-                    mutation,
-                    variables: variables || {},
-                });
-                if (result.errors) {
-                    const errorMessage = result.errors
-                        .map((err) => this.prettyPrintGraphQLError(err))
-                        .join("\n");
-                    throw new Error(errorMessage);
-                }
-                if (!result.data) {
-                    throw new Error("No data returned from mutation.");
-                }
-                return result.data;
+    async mutateAndCheckError(mutation, variables) {
+        if (this.client === undefined)
+            throw new Error("Apollo Client not configured.");
+        try {
+            const result = await this.client.mutate({
+                mutation,
+                variables: variables || {},
+            });
+            if (result.errors) {
+                const errorMessage = result.errors
+                    .map((err) => this.prettyPrintGraphQLError(err))
+                    .join("\n");
+                throw new Error(errorMessage);
             }
-            catch (error) {
-                if (error instanceof core_1.ApolloError && error.graphQLErrors.length > 0) {
-                    const errorMessage = error.graphQLErrors
-                        .map((err) => this.prettyPrintGraphQLError(err))
-                        .join("\n");
-                    console.error(errorMessage);
-                    throw new Error(errorMessage);
-                }
-                if (error instanceof Error) {
-                    console.error(error.message);
-                    throw error;
-                }
-                else {
-                    throw error;
-                }
+            if (!result.data) {
+                throw new Error("No data returned from mutation.");
             }
-        });
+            return result.data;
+        }
+        catch (error) {
+            if (error instanceof ApolloError && error.graphQLErrors.length > 0) {
+                const errorMessage = error.graphQLErrors
+                    .map((err) => this.prettyPrintGraphQLError(err))
+                    .join("\n");
+                console.error(errorMessage);
+                throw new Error(errorMessage);
+            }
+            if (error instanceof Error) {
+                console.error(error.message);
+                throw error;
+            }
+            else {
+                throw error;
+            }
+        }
     }
-    queryAndCheckError(query, variables) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.client === undefined)
-                throw new Error("Apollo Client not configured.");
-            try {
-                const result = yield this.client.query({
-                    query,
-                    variables: variables || {},
-                });
-                if (result.errors) {
-                    const errorMessage = result.errors
-                        .map((err) => this.prettyPrintGraphQLError(err))
-                        .join("\n");
-                    throw new Error(errorMessage);
-                }
-                if (!result.data) {
-                    throw new Error("No data returned from query.");
-                }
-                return result.data;
+    async queryAndCheckError(query, variables) {
+        if (this.client === undefined)
+            throw new Error("Apollo Client not configured.");
+        try {
+            const result = await this.client.query({
+                query,
+                variables: variables || {},
+            });
+            if (result.errors) {
+                const errorMessage = result.errors
+                    .map((err) => this.prettyPrintGraphQLError(err))
+                    .join("\n");
+                throw new Error(errorMessage);
             }
-            catch (error) {
-                if (error instanceof core_1.ApolloError && error.graphQLErrors.length > 0) {
-                    const errorMessage = error.graphQLErrors
-                        .map((err) => this.prettyPrintGraphQLError(err))
-                        .join("\n");
-                    console.error(errorMessage);
-                    throw new Error(errorMessage);
-                }
-                if (error instanceof Error) {
-                    console.error(error.message);
-                    throw error;
-                }
-                else {
-                    throw error;
-                }
+            if (!result.data) {
+                throw new Error("No data returned from query.");
             }
-        });
+            return result.data;
+        }
+        catch (error) {
+            if (error instanceof ApolloError && error.graphQLErrors.length > 0) {
+                const errorMessage = error.graphQLErrors
+                    .map((err) => this.prettyPrintGraphQLError(err))
+                    .join("\n");
+                console.error(errorMessage);
+                throw new Error(errorMessage);
+            }
+            if (error instanceof Error) {
+                console.error(error.message);
+                throw error;
+            }
+            else {
+                throw error;
+            }
+        }
     }
 }
-exports.Graphlit = Graphlit;
-exports.Types = __importStar(require("./generated/graphql-types.js"));
+export { Graphlit };
+export * as Types from "./generated/graphql-types.js";
+// Export streaming helpers
+export { StreamEventAggregator, formatSSEEvent, createSSEStream, wrapToolHandlers, enhanceToolCalls, ConversationMetrics, } from "./stream-helpers.js";