windmill-client 1.145.2 → 1.146.0

package/dist/services/VariableService.d.ts

@@ -0,0 +1,95 @@
+import type { ContextualVariable } from '../models/ContextualVariable';
+import type { CreateVariable } from '../models/CreateVariable';
+import type { EditVariable } from '../models/EditVariable';
+import type { ListableVariable } from '../models/ListableVariable';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class VariableService {
+    /**
+     * create variable
+     * @returns string variable created
+     * @throws ApiError
+     */
+    static createVariable({ workspace, requestBody, alreadyEncrypted, }: {
+        workspace: string;
+        /**
+         * new variable
+         */
+        requestBody: CreateVariable;
+        alreadyEncrypted?: boolean;
+    }): CancelablePromise<string>;
+    /**
+     * encrypt value
+     * @returns string encrypted value
+     * @throws ApiError
+     */
+    static encryptValue({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * new variable
+         */
+        requestBody: string;
+    }): CancelablePromise<string>;
+    /**
+     * delete variable
+     * @returns string variable deleted
+     * @throws ApiError
+     */
+    static deleteVariable({ workspace, path, }: {
+        workspace: string;
+        path: string;
+    }): CancelablePromise<string>;
+    /**
+     * update variable
+     * @returns string variable updated
+     * @throws ApiError
+     */
+    static updateVariable({ workspace, path, requestBody, alreadyEncrypted, }: {
+        workspace: string;
+        path: string;
+        /**
+         * updated variable
+         */
+        requestBody: EditVariable;
+        alreadyEncrypted?: boolean;
+    }): CancelablePromise<string>;
+    /**
+     * get variable
+     * @returns ListableVariable variable
+     * @throws ApiError
+     */
+    static getVariable({ workspace, path, decryptSecret, }: {
+        workspace: string;
+        path: string;
+        /**
+         * ask to decrypt secret if this variable is secret
+         * (if not secret no effect, default: true)
+         *
+         */
+        decryptSecret?: boolean;
+    }): CancelablePromise<ListableVariable>;
+    /**
+     * does variable exists at path
+     * @returns boolean variable
+     * @throws ApiError
+     */
+    static existsVariable({ workspace, path, }: {
+        workspace: string;
+        path: string;
+    }): CancelablePromise<boolean>;
+    /**
+     * list variables
+     * @returns ListableVariable variable list
+     * @throws ApiError
+     */
+    static listVariable({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<Array<ListableVariable>>;
+    /**
+     * list contextual variables
+     * @returns ContextualVariable contextual variable list
+     * @throws ApiError
+     */
+    static listContextualVariables({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<Array<ContextualVariable>>;
+}

package/dist/services/VariableService.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class VariableService {
+    /**
+     * create variable
+     * @returns string variable created
+     * @throws ApiError
+     */
+    static createVariable({ workspace, requestBody, alreadyEncrypted, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/variables/create',
+            path: {
+                'workspace': workspace,
+            },
+            query: {
+                'already_encrypted': alreadyEncrypted,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * encrypt value
+     * @returns string encrypted value
+     * @throws ApiError
+     */
+    static encryptValue({ workspace, requestBody, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/variables/encrypt',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * delete variable
+     * @returns string variable deleted
+     * @throws ApiError
+     */
+    static deleteVariable({ workspace, path, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'DELETE',
+            url: '/w/{workspace}/variables/delete/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * update variable
+     * @returns string variable updated
+     * @throws ApiError
+     */
+    static updateVariable({ workspace, path, requestBody, alreadyEncrypted, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/variables/update/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            query: {
+                'already_encrypted': alreadyEncrypted,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * get variable
+     * @returns ListableVariable variable
+     * @throws ApiError
+     */
+    static getVariable({ workspace, path, decryptSecret, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/variables/get/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            query: {
+                'decrypt_secret': decryptSecret,
+            },
+        });
+    }
+    /**
+     * does variable exists at path
+     * @returns boolean variable
+     * @throws ApiError
+     */
+    static existsVariable({ workspace, path, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/variables/exists/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * list variables
+     * @returns ListableVariable variable list
+     * @throws ApiError
+     */
+    static listVariable({ workspace, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/variables/list',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+    /**
+     * list contextual variables
+     * @returns ContextualVariable contextual variable list
+     * @throws ApiError
+     */
+    static listContextualVariables({ workspace, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/variables/list_contextual',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+}
+exports.VariableService = VariableService;

package/dist/services/WorkerService.d.ts

@@ -0,0 +1,25 @@
+import type { WorkerPing } from '../models/WorkerPing';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class WorkerService {
+    /**
+     * get all instance custom tags (tags are used to dispatch jobs to different worker groups)
+     * @returns string list of custom tags
+     * @throws ApiError
+     */
+    static getCustomTags(): CancelablePromise<Array<string>>;
+    /**
+     * list workers
+     * @returns WorkerPing a list of workers
+     * @throws ApiError
+     */
+    static listWorkers({ page, perPage, }: {
+        /**
+         * which page to return (start at 1, default 1)
+         */
+        page?: number;
+        /**
+         * number of items to return for a given page (default 30, max 100)
+         */
+        perPage?: number;
+    }): CancelablePromise<Array<WorkerPing>>;
+}

package/dist/services/WorkerService.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class WorkerService {
+    /**
+     * get all instance custom tags (tags are used to dispatch jobs to different worker groups)
+     * @returns string list of custom tags
+     * @throws ApiError
+     */
+    static getCustomTags() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/workers/custom_tags',
+        });
+    }
+    /**
+     * list workers
+     * @returns WorkerPing a list of workers
+     * @throws ApiError
+     */
+    static listWorkers({ page, perPage, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/workers/list',
+            query: {
+                'page': page,
+                'per_page': perPage,
+            },
+        });
+    }
+}
+exports.WorkerService = WorkerService;

package/dist/services/WorkspaceService.d.ts

@@ -0,0 +1,287 @@
+import type { CreateWorkspace } from '../models/CreateWorkspace';
+import type { UserWorkspaceList } from '../models/UserWorkspaceList';
+import type { Workspace } from '../models/Workspace';
+import type { WorkspaceInvite } from '../models/WorkspaceInvite';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class WorkspaceService {
+    /**
+     * list all workspaces visible to me
+     * @returns Workspace all workspaces
+     * @throws ApiError
+     */
+    static listWorkspaces(): CancelablePromise<Array<Workspace>>;
+    /**
+     * is domain allowed for auto invi
+     * @returns boolean domain allowed or not
+     * @throws ApiError
+     */
+    static isDomainAllowed(): CancelablePromise<boolean>;
+    /**
+     * list all workspaces visible to me with user info
+     * @returns UserWorkspaceList workspace with associated username
+     * @throws ApiError
+     */
+    static listUserWorkspaces(): CancelablePromise<UserWorkspaceList>;
+    /**
+     * list all workspaces as super admin (require to be super admin)
+     * @returns Workspace workspaces
+     * @throws ApiError
+     */
+    static listWorkspacesAsSuperAdmin({ page, perPage, }: {
+        /**
+         * which page to return (start at 1, default 1)
+         */
+        page?: number;
+        /**
+         * number of items to return for a given page (default 30, max 100)
+         */
+        perPage?: number;
+    }): CancelablePromise<Array<Workspace>>;
+    /**
+     * create workspace
+     * @returns string token created
+     * @throws ApiError
+     */
+    static createWorkspace({ requestBody, }: {
+        /**
+         * new token
+         */
+        requestBody: CreateWorkspace;
+    }): CancelablePromise<string>;
+    /**
+     * exists workspace
+     * @returns boolean status
+     * @throws ApiError
+     */
+    static existsWorkspace({ requestBody, }: {
+        /**
+         * id of workspace
+         */
+        requestBody: {
+            id: string;
+        };
+    }): CancelablePromise<boolean>;
+    /**
+     * exists username
+     * @returns boolean status
+     * @throws ApiError
+     */
+    static existsUsername({ requestBody, }: {
+        requestBody: {
+            id: string;
+            username: string;
+        };
+    }): CancelablePromise<boolean>;
+    /**
+     * invite user to workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    static inviteUser({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * WorkspaceInvite
+         */
+        requestBody: {
+            email: string;
+            is_admin: boolean;
+            operator: boolean;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * add user to workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    static addUser({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * WorkspaceInvite
+         */
+        requestBody: {
+            email: string;
+            is_admin: boolean;
+            username: string;
+            operator: boolean;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * delete user invite
+     * @returns string status
+     * @throws ApiError
+     */
+    static deleteInvite({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * WorkspaceInvite
+         */
+        requestBody: {
+            email: string;
+            is_admin: boolean;
+            operator: boolean;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * archive workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    static archiveWorkspace({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<string>;
+    /**
+     * unarchive workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    static unarchiveWorkspace({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<string>;
+    /**
+     * delete workspace (require super admin)
+     * @returns string status
+     * @throws ApiError
+     */
+    static deleteWorkspace({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<string>;
+    /**
+     * list pending invites for a workspace
+     * @returns WorkspaceInvite user
+     * @throws ApiError
+     */
+    static listPendingInvites({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<Array<WorkspaceInvite>>;
+    /**
+     * get settings
+     * @returns any status
+     * @throws ApiError
+     */
+    static getSettings({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<{
+        workspace_id?: string;
+        slack_name?: string;
+        slack_team_id?: string;
+        slack_command_script?: string;
+        auto_invite_domain?: string;
+        auto_invite_operator?: boolean;
+        plan?: string;
+        customer_id?: string;
+        webhook?: string;
+        deploy_to?: string;
+        openai_resource_path?: string;
+        error_handler?: string;
+    }>;
+    /**
+     * get deploy to
+     * @returns any status
+     * @throws ApiError
+     */
+    static getDeployTo({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<{
+        deploy_to?: string;
+    }>;
+    /**
+     * get premium info
+     * @returns any status
+     * @throws ApiError
+     */
+    static getPremiumInfo({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<{
+        premium: boolean;
+        usage?: number;
+    }>;
+    /**
+     * edit slack command
+     * @returns string status
+     * @throws ApiError
+     */
+    static editSlackCommand({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * WorkspaceInvite
+         */
+        requestBody: {
+            slack_command_script?: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * edit deploy to
+     * @returns string status
+     * @throws ApiError
+     */
+    static editDeployTo({ workspace, requestBody, }: {
+        workspace: string;
+        requestBody: {
+            deploy_to?: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * edit auto invite
+     * @returns string status
+     * @throws ApiError
+     */
+    static editAutoInvite({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * WorkspaceInvite
+         */
+        requestBody: {
+            operator?: boolean;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * edit webhook
+     * @returns string status
+     * @throws ApiError
+     */
+    static editWebhook({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * WorkspaceWebhook
+         */
+        requestBody: {
+            webhook?: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * edit OpenAI resource path
+     * @returns string status
+     * @throws ApiError
+     */
+    static editOpenaiResourcePath({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * WorkspaceOpenaiResourcePath
+         */
+        requestBody: {
+            openai_resource_path?: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * OpenAI resource path exists
+     * @returns boolean status
+     * @throws ApiError
+     */
+    static existsOpenaiResourcePath({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<boolean>;
+    /**
+     * edit error handler
+     * @returns string status
+     * @throws ApiError
+     */
+    static editErrorHandler({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * WorkspaceErrorHandler
+         */
+        requestBody: {
+            error_handler?: string;
+        };
+    }): CancelablePromise<string>;
+}