windmill-client 0.1.0

package/src/services/VariableService.ts

@@ -0,0 +1,194 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+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';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+
+export class VariableService {
+
+    /**
+     * create variable
+     * @returns string variable created
+     * @throws ApiError
+     */
+    public static createVariable({
+        workspace,
+        requestBody,
+        alreadyEncrypted,
+    }: {
+        workspace: string,
+        /**
+         * new variable
+         */
+        requestBody: CreateVariable,
+        alreadyEncrypted?: boolean,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/variables/create',
+            path: {
+                'workspace': workspace,
+            },
+            query: {
+                'already_encrypted': alreadyEncrypted,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * delete variable
+     * @returns string variable deleted
+     * @throws ApiError
+     */
+    public static deleteVariable({
+        workspace,
+        path,
+    }: {
+        workspace: string,
+        path: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/w/{workspace}/variables/delete/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+
+    /**
+     * update variable
+     * @returns string variable updated
+     * @throws ApiError
+     */
+    public static updateVariable({
+        workspace,
+        path,
+        requestBody,
+        alreadyEncrypted,
+    }: {
+        workspace: string,
+        path: string,
+        /**
+         * updated variable
+         */
+        requestBody: EditVariable,
+        alreadyEncrypted?: boolean,
+    }): CancelablePromise<string> {
+        return __request(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
+     */
+    public 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> {
+        return __request(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
+     */
+    public static existsVariable({
+        workspace,
+        path,
+    }: {
+        workspace: string,
+        path: string,
+    }): CancelablePromise<boolean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/variables/exists/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+
+    /**
+     * list variables
+     * @returns ListableVariable variable list
+     * @throws ApiError
+     */
+    public static listVariable({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<Array<ListableVariable>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/variables/list',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * list contextual variables
+     * @returns ContextualVariable contextual variable list
+     * @throws ApiError
+     */
+    public static listContextualVariables({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<Array<ContextualVariable>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/variables/list_contextual',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+}

package/src/services/WorkerService.ts

@@ -0,0 +1,52 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { WorkerPing } from '../models/WorkerPing';
+
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+
+export 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
+     */
+    public static getCustomTags(): CancelablePromise<Array<string>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/workers/custom_tags',
+        });
+    }
+
+    /**
+     * list workers
+     * @returns WorkerPing a list of workers
+     * @throws ApiError
+     */
+    public 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>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/workers/list',
+            query: {
+                'page': page,
+                'per_page': perPage,
+            },
+        });
+    }
+
+}

package/src/services/WorkspaceService.ts

@@ -0,0 +1,446 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+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';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+
+export class WorkspaceService {
+
+    /**
+     * list all workspaces visible to me
+     * @returns Workspace all workspaces
+     * @throws ApiError
+     */
+    public static listWorkspaces(): CancelablePromise<Array<Workspace>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/workspaces/list',
+        });
+    }
+
+    /**
+     * is domain allowed for auto invi
+     * @returns boolean domain allowed or not
+     * @throws ApiError
+     */
+    public static isDomainAllowed(): CancelablePromise<boolean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/workspaces/allowed_domain_auto_invite',
+        });
+    }
+
+    /**
+     * list all workspaces visible to me with user info
+     * @returns UserWorkspaceList workspace with associated username
+     * @throws ApiError
+     */
+    public static listUserWorkspaces(): CancelablePromise<UserWorkspaceList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/workspaces/users',
+        });
+    }
+
+    /**
+     * list all workspaces as super admin (require to be super admin)
+     * @returns Workspace workspaces
+     * @throws ApiError
+     */
+    public 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>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/workspaces/list_as_superadmin',
+            query: {
+                'page': page,
+                'per_page': perPage,
+            },
+        });
+    }
+
+    /**
+     * create workspace
+     * @returns string token created
+     * @throws ApiError
+     */
+    public static createWorkspace({
+        requestBody,
+    }: {
+        /**
+         * new token
+         */
+        requestBody: CreateWorkspace,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/workspaces/create',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * exists workspace
+     * @returns boolean status
+     * @throws ApiError
+     */
+    public static existsWorkspace({
+        requestBody,
+    }: {
+        /**
+         * id of workspace
+         */
+        requestBody: {
+            id: string;
+        },
+    }): CancelablePromise<boolean> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/workspaces/exists',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * exists username
+     * @returns boolean status
+     * @throws ApiError
+     */
+    public static existsUsername({
+        requestBody,
+    }: {
+        requestBody: {
+            id: string;
+            username: string;
+        },
+    }): CancelablePromise<boolean> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/workspaces/exists_username',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * invite user to workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    public static inviteUser({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        /**
+         * WorkspaceInvite
+         */
+        requestBody: {
+            email: string;
+            is_admin: boolean;
+            operator: boolean;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/workspaces/invite_user',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * add user to workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    public static addUser({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        /**
+         * WorkspaceInvite
+         */
+        requestBody: {
+            email: string;
+            is_admin: boolean;
+            username: string;
+            operator: boolean;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/workspaces/add_user',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * delete user invite
+     * @returns string status
+     * @throws ApiError
+     */
+    public static deleteInvite({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        /**
+         * WorkspaceInvite
+         */
+        requestBody: {
+            email: string;
+            is_admin: boolean;
+            operator: boolean;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/workspaces/delete_invite',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * archive workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    public static archiveWorkspace({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/workspaces/archive',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * unarchive workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    public static unarchiveWorkspace({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/workspaces/unarchive/{workspace}',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * delete workspace (require super admin)
+     * @returns string status
+     * @throws ApiError
+     */
+    public static deleteWorkspace({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/workspaces/delete/{workspace}',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * list pending invites for a workspace
+     * @returns WorkspaceInvite user
+     * @throws ApiError
+     */
+    public static listPendingInvites({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<Array<WorkspaceInvite>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/workspaces/list_pending_invites',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * get settings
+     * @returns any status
+     * @throws ApiError
+     */
+    public 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;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/workspaces/get_settings',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * get premium info
+     * @returns any status
+     * @throws ApiError
+     */
+    public static getPremiumInfo({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<{
+        premium: boolean;
+        usage?: number;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/workspaces/premium_info',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * edit slack command
+     * @returns string status
+     * @throws ApiError
+     */
+    public static editSlackCommand({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        /**
+         * WorkspaceInvite
+         */
+        requestBody: {
+            slack_command_script?: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/workspaces/edit_slack_command',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * edit auto invite
+     * @returns string status
+     * @throws ApiError
+     */
+    public static editAutoInvite({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        /**
+         * WorkspaceInvite
+         */
+        requestBody: {
+            operator?: boolean;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/workspaces/edit_auto_invite',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * edit webhook
+     * @returns string status
+     * @throws ApiError
+     */
+    public static editWebhook({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        /**
+         * WorkspaceWebhook
+         */
+        requestBody: {
+            webhook?: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/workspaces/edit_webhook',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+}