lemma-sdk 0.2.0

package/dist/namespaces/desks.js

@@ -0,0 +1,35 @@
+import { DesksService } from "../openapi_client/services/DesksService.js";
+export class DesksNamespace {
+    client;
+    http;
+    podId;
+    constructor(client, http, podId) {
+        this.client = client;
+        this.http = http;
+        this.podId = podId;
+    }
+    list(options = {}) {
+        return this.client.request(() => DesksService.podDeskList(this.podId(), options.limit ?? 100, options.pageToken));
+    }
+    create(payload) {
+        return this.client.request(() => DesksService.podDeskCreate(this.podId(), payload));
+    }
+    get(name) {
+        return this.client.request(() => DesksService.podDeskGet(this.podId(), name));
+    }
+    update(name, payload) {
+        return this.client.request(() => DesksService.podDeskUpdate(this.podId(), name, payload));
+    }
+    delete(name) {
+        return this.client.request(() => DesksService.podDeskDelete(this.podId(), name));
+    }
+    html = {
+        get: (name) => this.client.request(() => DesksService.podDeskHtmlGet(this.podId(), name)),
+    };
+    bundle = {
+        upload: (name, payload) => this.client.request(() => DesksService.podDeskBundleUpload(this.podId(), name, payload)),
+    };
+    source = {
+        download: (name) => this.http.requestBytes("GET", `/pods/${this.podId()}/desks/${name}/source/archive`),
+    };
+}

package/dist/namespaces/files.d.ts

@@ -0,0 +1,40 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { HttpClient } from "../http.js";
+import { SearchMethod } from "../openapi_client/models/SearchMethod.js";
+export declare class FilesNamespace {
+    private readonly client;
+    private readonly http;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, http: HttpClient, podId: () => string);
+    list(datastore: string, options?: {
+        limit?: number;
+        pageToken?: string;
+        parentId?: string;
+    }): Promise<import("../index.js").FileListResponse>;
+    get(datastore: string, fileId: string): Promise<import("../index.js").FileResponse>;
+    delete(datastore: string, fileId: string): Promise<import("../index.js").DatastoreMessageResponse>;
+    search(datastore: string, query: string, options?: {
+        limit?: number;
+        searchMethod?: SearchMethod;
+    }): Promise<import("../index.js").FileSearchResponse>;
+    download(datastore: string, fileId: string): Promise<Blob>;
+    upload(datastore: string, file: Blob, options?: {
+        name?: string;
+        parentId?: string;
+        searchEnabled?: boolean;
+        description?: string;
+    }): Promise<import("../index.js").FileResponse>;
+    update(datastore: string, fileId: string, options?: {
+        file?: Blob;
+        name?: string;
+        description?: string;
+        parentId?: string;
+        searchEnabled?: boolean;
+    }): Promise<import("../index.js").FileResponse>;
+    readonly folder: {
+        create: (datastore: string, name: string, options?: {
+            parentId?: string;
+            description?: string;
+        }) => Promise<import("../index.js").FileResponse>;
+    };
+}

package/dist/namespaces/files.js

@@ -0,0 +1,61 @@
+import { SearchMethod } from "../openapi_client/models/SearchMethod.js";
+import { FilesService } from "../openapi_client/services/FilesService.js";
+export class FilesNamespace {
+    client;
+    http;
+    podId;
+    constructor(client, http, podId) {
+        this.client = client;
+        this.http = http;
+        this.podId = podId;
+    }
+    list(datastore, options = {}) {
+        return this.client.request(() => FilesService.fileList(this.podId(), datastore, options.parentId, options.limit ?? 100, options.pageToken));
+    }
+    get(datastore, fileId) {
+        return this.client.request(() => FilesService.fileGet(this.podId(), datastore, fileId));
+    }
+    delete(datastore, fileId) {
+        return this.client.request(() => FilesService.fileDelete(this.podId(), datastore, fileId));
+    }
+    search(datastore, query, options = {}) {
+        return this.client.request(() => FilesService.fileSearch(this.podId(), datastore, {
+            query,
+            limit: options.limit ?? 10,
+            search_method: options.searchMethod ?? SearchMethod.HYBRID,
+        }));
+    }
+    download(datastore, fileId) {
+        return this.http.requestBytes("GET", `/pods/${this.podId()}/datastores/${datastore}/files/${fileId}/download`);
+    }
+    upload(datastore, file, options = {}) {
+        const payload = {
+            data: file,
+            name: options.name ?? (file instanceof File ? file.name : undefined),
+            description: options.description,
+            parent_id: options.parentId,
+            search_enabled: options.searchEnabled ?? true,
+        };
+        return this.client.request(() => FilesService.fileUpload(this.podId(), datastore, payload));
+    }
+    update(datastore, fileId, options = {}) {
+        const payload = {
+            data: options.file,
+            name: options.name,
+            description: options.description,
+            parent_id: options.parentId,
+            search_enabled: options.searchEnabled,
+        };
+        return this.client.request(() => FilesService.fileUpdate(this.podId(), datastore, fileId, payload));
+    }
+    folder = {
+        create: (datastore, name, options = {}) => {
+            const payload = {
+                name,
+                description: options.description,
+                parent_id: options.parentId,
+            };
+            return this.client.request(() => FilesService.fileFolderCreate(this.podId(), datastore, payload));
+        },
+    };
+}

package/dist/namespaces/functions.d.ts

@@ -0,0 +1,25 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { CreateFunctionRequest } from "../openapi_client/models/CreateFunctionRequest.js";
+import type { UpdateFunctionRequest } from "../openapi_client/models/UpdateFunctionRequest.js";
+import type { RunFunctionOptions } from "../types.js";
+export declare class FunctionsNamespace {
+    private readonly client;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, podId: () => string);
+    list(options?: {
+        limit?: number;
+        pageToken?: string;
+    }): Promise<import("../index.js").FunctionListResponse>;
+    create(payload: CreateFunctionRequest): Promise<import("../index.js").FunctionResponse>;
+    get(name: string): Promise<import("../index.js").FunctionResponse>;
+    update(name: string, payload: UpdateFunctionRequest): Promise<import("../index.js").FunctionResponse>;
+    delete(name: string): Promise<import("../index.js").FunctionMessageResponse>;
+    readonly runs: {
+        create: (name: string, options?: RunFunctionOptions) => Promise<import("../index.js").FunctionRunResponse>;
+        list: (name: string, params?: {
+            limit?: number;
+            pageToken?: string;
+        }) => Promise<import("../index.js").FunctionRunListResponse>;
+        get: (name: string, runId: string) => Promise<import("../index.js").FunctionRunResponse>;
+    };
+}

package/dist/namespaces/functions.js

@@ -0,0 +1,32 @@
+import { FunctionsService } from "../openapi_client/services/FunctionsService.js";
+export class FunctionsNamespace {
+    client;
+    podId;
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+    }
+    list(options = {}) {
+        return this.client.request(() => FunctionsService.functionList(this.podId(), options.limit ?? 100, options.pageToken));
+    }
+    create(payload) {
+        return this.client.request(() => FunctionsService.functionCreate(this.podId(), payload));
+    }
+    get(name) {
+        return this.client.request(() => FunctionsService.functionGet(this.podId(), name));
+    }
+    update(name, payload) {
+        return this.client.request(() => FunctionsService.functionUpdate(this.podId(), name, payload));
+    }
+    delete(name) {
+        return this.client.request(() => FunctionsService.functionDelete(this.podId(), name));
+    }
+    runs = {
+        create: (name, options = {}) => this.client.request(() => {
+            const payload = { input_data: options.input };
+            return FunctionsService.functionRun(this.podId(), name, payload);
+        }),
+        list: (name, params = {}) => this.client.request(() => FunctionsService.functionRunList(this.podId(), name, params.limit ?? 100, params.pageToken)),
+        get: (name, runId) => this.client.request(() => FunctionsService.functionRunGet(this.podId(), name, runId)),
+    };
+}

package/dist/namespaces/integrations.d.ts

@@ -0,0 +1,36 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+export declare class IntegrationsNamespace {
+    private readonly client;
+    constructor(client: GeneratedClientAdapter);
+    list(options?: {
+        limit?: number;
+        pageToken?: string;
+    }): Promise<import("../index.js").ApplicationListResponseSchema>;
+    get(applicationId: string): Promise<import("../index.js").ApplicationDetailResponseSchema>;
+    readonly operations: {
+        list: (applicationId: string) => Promise<import("../index.js").OperationListResponse>;
+        get: (applicationId: string, operationName: string) => Promise<import("../index.js").OperationDetail>;
+        execute: (applicationId: string, operationName: string, payload: Record<string, unknown>, accountId?: string) => Promise<import("../index.js").OperationExecutionResponse>;
+        descriptor: (applicationId: string) => Promise<import("../index.js").AppDescriptorResponse>;
+    };
+    readonly triggers: {
+        list: (options?: {
+            applicationId?: string;
+            search?: string;
+            limit?: number;
+            pageToken?: string;
+        }) => Promise<import("../index.js").AppTriggerListResponseSchema>;
+        get: (triggerId: string) => Promise<import("../index.js").AppTriggerResponseSchema>;
+    };
+    readonly accounts: {
+        list: (options?: {
+            applicationId?: string;
+            limit?: number;
+            pageToken?: string;
+        }) => Promise<import("../index.js").AccountListResponseSchema>;
+        get: (accountId: string) => Promise<import("../index.js").AccountResponseSchema>;
+        credentials: (accountId: string) => Promise<import("../index.js").AccountCredentialsResponseSchema>;
+        delete: (accountId: string) => Promise<import("../index.js").MessageResponseSchema>;
+    };
+    createConnectRequest(applicationId: string): Promise<import("../index.js").ConnectRequestResponseSchema>;
+}

package/dist/namespaces/integrations.js

@@ -0,0 +1,37 @@
+import { ApplicationsService } from "../openapi_client/services/ApplicationsService.js";
+import { IntegrationsService } from "../openapi_client/services/IntegrationsService.js";
+export class IntegrationsNamespace {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(options = {}) {
+        return this.client.request(() => ApplicationsService.applicationList(options.limit ?? 100, options.pageToken));
+    }
+    get(applicationId) {
+        return this.client.request(() => ApplicationsService.applicationGet(applicationId));
+    }
+    operations = {
+        list: (applicationId) => this.client.request(() => ApplicationsService.applicationOperationList(applicationId)),
+        get: (applicationId, operationName) => this.client.request(() => ApplicationsService.applicationOperationDetail(applicationId, operationName)),
+        execute: (applicationId, operationName, payload, accountId) => {
+            const body = { payload, account_id: accountId };
+            return this.client.request(() => ApplicationsService.applicationOperationExecute(applicationId, operationName, body));
+        },
+        descriptor: (applicationId) => this.client.request(() => ApplicationsService.applicationDescriptor(applicationId)),
+    };
+    triggers = {
+        list: (options = {}) => this.client.request(() => ApplicationsService.applicationTriggerList(options.applicationId, options.search, options.limit ?? 100, options.pageToken)),
+        get: (triggerId) => this.client.request(() => ApplicationsService.applicationTriggerGet(triggerId)),
+    };
+    accounts = {
+        list: (options = {}) => this.client.request(() => IntegrationsService.integrationAccountList(options.applicationId, options.limit ?? 100, options.pageToken)),
+        get: (accountId) => this.client.request(() => IntegrationsService.integrationAccountGet(accountId)),
+        credentials: (accountId) => this.client.request(() => IntegrationsService.integrationAccountCredentialsGet(accountId)),
+        delete: (accountId) => this.client.request(() => IntegrationsService.integrationAccountDelete(accountId)),
+    };
+    createConnectRequest(applicationId) {
+        const payload = { application_id: applicationId };
+        return this.client.request(() => IntegrationsService.integrationConnectRequestCreate(payload));
+    }
+}

package/dist/namespaces/records.d.ts

@@ -0,0 +1,19 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { RecordQueryRequest } from "../openapi_client/models/RecordQueryRequest.js";
+import type { ListRecordsOptions } from "../types.js";
+export declare class RecordsNamespace {
+    private readonly client;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, podId: () => string);
+    list(datastore: string, table: string, options?: ListRecordsOptions): Promise<import("../index.js").RecordListResponse>;
+    create(datastore: string, table: string, data: Record<string, unknown>): Promise<import("../index.js").RecordResponse>;
+    get(datastore: string, table: string, recordId: string): Promise<import("../index.js").RecordResponse>;
+    update(datastore: string, table: string, recordId: string, data: Record<string, unknown>): Promise<import("../index.js").RecordResponse>;
+    delete(datastore: string, table: string, recordId: string): Promise<import("../index.js").DatastoreMessageResponse>;
+    query(datastore: string, table: string, payload: RecordQueryRequest): Promise<import("../index.js").RecordListResponse>;
+    readonly bulk: {
+        create: (datastore: string, table: string, records: Record<string, unknown>[]) => Promise<import("../index.js").DatastoreMessageResponse>;
+        update: (datastore: string, table: string, records: Record<string, unknown>[]) => Promise<import("../index.js").DatastoreMessageResponse>;
+        delete: (datastore: string, table: string, recordIds: string[]) => Promise<import("../index.js").DatastoreMessageResponse>;
+    };
+}

package/dist/namespaces/records.js

@@ -0,0 +1,46 @@
+import { RecordsService } from "../openapi_client/services/RecordsService.js";
+export class RecordsNamespace {
+    client;
+    podId;
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+    }
+    list(datastore, table, options = {}) {
+        const { filters, sort, limit, pageToken } = options;
+        if (filters || sort) {
+            const payload = { filters, sort, limit, page_token: pageToken };
+            return this.client.request(() => RecordsService.recordQuery(this.podId(), datastore, table, payload));
+        }
+        return this.client.request(() => RecordsService.recordList(this.podId(), datastore, table, limit ?? 20, pageToken));
+    }
+    create(datastore, table, data) {
+        return this.client.request(() => RecordsService.recordCreate(this.podId(), datastore, table, { data }));
+    }
+    get(datastore, table, recordId) {
+        return this.client.request(() => RecordsService.recordGet(this.podId(), datastore, table, recordId));
+    }
+    update(datastore, table, recordId, data) {
+        return this.client.request(() => RecordsService.recordUpdate(this.podId(), datastore, table, recordId, { data }));
+    }
+    delete(datastore, table, recordId) {
+        return this.client.request(() => RecordsService.recordDelete(this.podId(), datastore, table, recordId));
+    }
+    query(datastore, table, payload) {
+        return this.client.request(() => RecordsService.recordQuery(this.podId(), datastore, table, payload));
+    }
+    bulk = {
+        create: (datastore, table, records) => {
+            const payload = { records };
+            return this.client.request(() => RecordsService.recordBulkCreate(this.podId(), datastore, table, payload));
+        },
+        update: (datastore, table, records) => {
+            const payload = { records };
+            return this.client.request(() => RecordsService.recordBulkUpdate(this.podId(), datastore, table, payload));
+        },
+        delete: (datastore, table, recordIds) => {
+            const payload = { record_ids: recordIds };
+            return this.client.request(() => RecordsService.recordBulkDelete(this.podId(), datastore, table, payload));
+        },
+    };
+}

package/dist/namespaces/tables.d.ts

@@ -0,0 +1,21 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { AddColumnRequest } from "../openapi_client/models/AddColumnRequest.js";
+import type { CreateTableRequest } from "../openapi_client/models/CreateTableRequest.js";
+import type { UpdateTableRequest } from "../openapi_client/models/UpdateTableRequest.js";
+export declare class TablesNamespace {
+    private readonly client;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, podId: () => string);
+    list(datastore: string, options?: {
+        limit?: number;
+        pageToken?: string;
+    }): Promise<import("../index.js").TableListResponse>;
+    create(datastore: string, payload: CreateTableRequest): Promise<import("../index.js").TableResponse>;
+    get(datastore: string, tableName: string): Promise<import("../index.js").TableResponse>;
+    update(datastore: string, tableName: string, payload: UpdateTableRequest): Promise<import("../index.js").TableResponse>;
+    delete(datastore: string, tableName: string): Promise<import("../index.js").DatastoreMessageResponse>;
+    readonly columns: {
+        add: (datastore: string, tableName: string, request: AddColumnRequest | AddColumnRequest["column"]) => Promise<import("../index.js").TableResponse>;
+        remove: (datastore: string, tableName: string, columnName: string) => Promise<import("../index.js").DatastoreMessageResponse>;
+    };
+}

package/dist/namespaces/tables.js

@@ -0,0 +1,31 @@
+import { TablesService } from "../openapi_client/services/TablesService.js";
+export class TablesNamespace {
+    client;
+    podId;
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+    }
+    list(datastore, options = {}) {
+        return this.client.request(() => TablesService.tableList(this.podId(), datastore, options.limit ?? 100, options.pageToken));
+    }
+    create(datastore, payload) {
+        return this.client.request(() => TablesService.tableCreate(this.podId(), datastore, payload));
+    }
+    get(datastore, tableName) {
+        return this.client.request(() => TablesService.tableGet(this.podId(), datastore, tableName));
+    }
+    update(datastore, tableName, payload) {
+        return this.client.request(() => TablesService.tableUpdate(this.podId(), datastore, tableName, payload));
+    }
+    delete(datastore, tableName) {
+        return this.client.request(() => TablesService.tableDelete(this.podId(), datastore, tableName));
+    }
+    columns = {
+        add: (datastore, tableName, request) => {
+            const payload = "column" in request ? request : { column: request };
+            return this.client.request(() => TablesService.tableColumnAdd(this.podId(), datastore, tableName, payload));
+        },
+        remove: (datastore, tableName, columnName) => this.client.request(() => TablesService.tableColumnRemove(this.podId(), datastore, tableName, columnName)),
+    };
+}

package/dist/namespaces/tasks.d.ts

@@ -0,0 +1,22 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { CreateTaskOptions } from "../types.js";
+export declare class TasksNamespace {
+    private readonly client;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, podId: () => string);
+    list(options?: {
+        agentName?: string;
+        limit?: number;
+        pageToken?: string;
+    }): Promise<import("../index.js").TaskListResponse>;
+    create(options: CreateTaskOptions): Promise<import("../index.js").TaskResponse>;
+    get(taskId: string): Promise<import("../index.js").TaskResponse>;
+    stop(taskId: string): Promise<import("../index.js").TaskResponse>;
+    readonly messages: {
+        list: (taskId: string, options?: {
+            limit?: number;
+            pageToken?: string;
+        }) => Promise<import("../index.js").TaskMessageListResponse>;
+        add: (taskId: string, content: string) => Promise<import("../index.js").TaskResponse>;
+    };
+}

package/dist/namespaces/tasks.js

@@ -0,0 +1,29 @@
+import { TasksService } from "../openapi_client/services/TasksService.js";
+export class TasksNamespace {
+    client;
+    podId;
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+    }
+    list(options = {}) {
+        return this.client.request(() => TasksService.taskList(this.podId(), options.agentName, options.limit ?? 100, options.pageToken));
+    }
+    create(options) {
+        const payload = { agent_name: options.agentName, input_data: options.input };
+        return this.client.request(() => TasksService.taskCreate(this.podId(), payload));
+    }
+    get(taskId) {
+        return this.client.request(() => TasksService.taskGet(this.podId(), taskId));
+    }
+    stop(taskId) {
+        return this.client.request(() => TasksService.taskStop(this.podId(), taskId));
+    }
+    messages = {
+        list: (taskId, options = {}) => this.client.request(() => TasksService.taskMessageList(this.podId(), taskId, options.limit ?? 100, options.pageToken)),
+        add: (taskId, content) => {
+            const payload = { content };
+            return this.client.request(() => TasksService.taskMessageAdd(this.podId(), taskId, payload));
+        },
+    };
+}

package/dist/namespaces/workflows.d.ts

@@ -0,0 +1,35 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { WorkflowCreateRequest } from "../openapi_client/models/WorkflowCreateRequest.js";
+import type { WorkflowGraphUpdateRequest } from "../openapi_client/models/WorkflowGraphUpdateRequest.js";
+import type { WorkflowInstallRequest } from "../openapi_client/models/WorkflowInstallRequest.js";
+import type { WorkflowUpdateRequest } from "../openapi_client/models/WorkflowUpdateRequest.js";
+import type { WorkflowRunInputs } from "../types.js";
+export declare class WorkflowsNamespace {
+    private readonly client;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, podId: () => string);
+    list(options?: {
+        limit?: number;
+        pageToken?: string;
+    }): Promise<import("../index.js").WorkflowListResponse>;
+    create(payload: WorkflowCreateRequest): Promise<import("../index.js").FlowEntity>;
+    get(workflowName: string): Promise<import("../index.js").FlowEntity>;
+    update(workflowName: string, payload: WorkflowUpdateRequest): Promise<import("../index.js").FlowEntity>;
+    delete(workflowName: string): Promise<void>;
+    readonly graph: {
+        update: (workflowName: string, graph: WorkflowGraphUpdateRequest) => Promise<import("../index.js").FlowEntity>;
+    };
+    readonly installs: {
+        create: (workflowName: string, payload?: WorkflowInstallRequest) => Promise<import("../index.js").FlowInstallEntity>;
+        delete: (workflowName: string, installId: string) => Promise<void>;
+    };
+    readonly runs: {
+        start: (workflowName: string, inputs?: WorkflowRunInputs) => Promise<import("../index.js").FlowRunEntity>;
+        list: (workflowName: string, options?: {
+            limit?: number;
+            pageToken?: string;
+        }) => Promise<import("../index.js").WorkflowRunListResponse>;
+        get: (runId: string, podId?: string) => Promise<import("../index.js").FlowRunEntity>;
+        resume: (runId: string, inputs?: WorkflowRunInputs, podId?: string) => Promise<import("../index.js").FlowRunEntity>;
+    };
+}

package/dist/namespaces/workflows.js

@@ -0,0 +1,37 @@
+import { WorkflowsService } from "../openapi_client/services/WorkflowsService.js";
+export class WorkflowsNamespace {
+    client;
+    podId;
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+    }
+    list(options = {}) {
+        return this.client.request(() => WorkflowsService.workflowList(this.podId(), options.limit ?? 100, options.pageToken));
+    }
+    create(payload) {
+        return this.client.request(() => WorkflowsService.workflowCreate(this.podId(), payload));
+    }
+    get(workflowName) {
+        return this.client.request(() => WorkflowsService.workflowGet(this.podId(), workflowName));
+    }
+    update(workflowName, payload) {
+        return this.client.request(() => WorkflowsService.workflowUpdate(this.podId(), workflowName, payload));
+    }
+    delete(workflowName) {
+        return this.client.request(() => WorkflowsService.workflowDelete(this.podId(), workflowName));
+    }
+    graph = {
+        update: (workflowName, graph) => this.client.request(() => WorkflowsService.workflowGraphUpdate(this.podId(), workflowName, graph)),
+    };
+    installs = {
+        create: (workflowName, payload = {}) => this.client.request(() => WorkflowsService.workflowInstallCreate(this.podId(), workflowName, payload)),
+        delete: (workflowName, installId) => this.client.request(() => WorkflowsService.workflowInstallDelete(this.podId(), workflowName, installId)),
+    };
+    runs = {
+        start: (workflowName, inputs = {}) => this.client.request(() => WorkflowsService.workflowStart(this.podId(), workflowName, inputs)),
+        list: (workflowName, options = {}) => this.client.request(() => WorkflowsService.workflowRunList(this.podId(), workflowName, options.limit ?? 100, options.pageToken)),
+        get: (runId, podId = this.podId()) => this.client.request(() => WorkflowsService.workflowRunGet(podId, runId)),
+        resume: (runId, inputs = {}, podId = this.podId()) => this.client.request(() => WorkflowsService.workflowRunResume(podId, runId, inputs)),
+    };
+}

package/dist/openapi_client/core/ApiError.d.ts

@@ -0,0 +1,10 @@
+import type { ApiRequestOptions } from './ApiRequestOptions.js';
+import type { ApiResult } from './ApiResult.js';
+export declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}

package/dist/openapi_client/core/ApiError.js

@@ -0,0 +1,16 @@
+export class ApiError extends Error {
+    url;
+    status;
+    statusText;
+    body;
+    request;
+    constructor(request, response, message) {
+        super(message);
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}

package/dist/openapi_client/core/ApiRequestOptions.d.ts

@@ -0,0 +1,13 @@
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/dist/openapi_client/core/ApiRequestOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/openapi_client/core/ApiResult.d.ts

@@ -0,0 +1,7 @@
+export type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};

package/dist/openapi_client/core/ApiResult.js

@@ -0,0 +1 @@
+export {};

package/dist/openapi_client/core/CancelablePromise.d.ts

@@ -0,0 +1,20 @@
+export declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+export interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+export declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}