windmill-client 0.2.0 → 0.2.1

package/dist/services/ScriptService.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class ScriptService {
+    /**
+     * list all available hub scripts
+     * @returns any hub scripts list
+     * @throws ApiError
+     */
+    static listHubScripts() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/scripts/hub/list',
+        });
+    }
+    /**
+     * get hub script content by path
+     * @returns string script details
+     * @throws ApiError
+     */
+    static getHubScriptContentByPath({ path, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/scripts/hub/get/{path}',
+            path: {
+                'path': path,
+            },
+        });
+    }
+    /**
+     * get full hub script by path
+     * @returns any script details
+     * @throws ApiError
+     */
+    static getHubScriptByPath({ path, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/scripts/hub/get_full/{path}',
+            path: {
+                'path': path,
+            },
+        });
+    }
+    /**
+     * list all available scripts
+     * @returns Script All available scripts
+     * @throws ApiError
+     */
+    static listScripts({ workspace, page, perPage, orderDesc, createdBy, pathStart, pathExact, firstParentHash, lastParentHash, parentHash, showArchived, isTemplate, kind, starredOnly, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/scripts/list',
+            path: {
+                'workspace': workspace,
+            },
+            query: {
+                'page': page,
+                'per_page': perPage,
+                'order_desc': orderDesc,
+                'created_by': createdBy,
+                'path_start': pathStart,
+                'path_exact': pathExact,
+                'first_parent_hash': firstParentHash,
+                'last_parent_hash': lastParentHash,
+                'parent_hash': parentHash,
+                'show_archived': showArchived,
+                'is_template': isTemplate,
+                'kind': kind,
+                'starred_only': starredOnly,
+            },
+        });
+    }
+    /**
+     * list all available scripts paths
+     * @returns string list of script paths
+     * @throws ApiError
+     */
+    static listScriptPaths({ workspace, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/scripts/list_paths',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+    /**
+     * create script
+     * @returns string script created
+     * @throws ApiError
+     */
+    static createScript({ workspace, requestBody, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/scripts/create',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * inspect python code to infer jsonschema of arguments
+     * @returns MainArgSignature parsed args
+     * @throws ApiError
+     */
+    static pythonToJsonschema({ requestBody, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/scripts/python/tojsonschema',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * inspect deno code to infer jsonschema of arguments
+     * @returns MainArgSignature parsed args
+     * @throws ApiError
+     */
+    static denoToJsonschema({ requestBody, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/scripts/deno/tojsonschema',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * inspect bash code to infer jsonschema of arguments
+     * @returns MainArgSignature parsed args
+     * @throws ApiError
+     */
+    static bashToJsonschema({ requestBody, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/scripts/bash/tojsonschema',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * inspect go code to infer jsonschema of arguments
+     * @returns MainArgSignature parsed args
+     * @throws ApiError
+     */
+    static goToJsonschema({ requestBody, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/scripts/go/tojsonschema',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * archive script by path
+     * @returns string script archived
+     * @throws ApiError
+     */
+    static archiveScriptByPath({ workspace, path, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/scripts/archive/p/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * archive script by hash
+     * @returns Script script details
+     * @throws ApiError
+     */
+    static archiveScriptByHash({ workspace, hash, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/scripts/archive/h/{hash}',
+            path: {
+                'workspace': workspace,
+                'hash': hash,
+            },
+        });
+    }
+    /**
+     * delete script by hash (erase content but keep hash, require admin)
+     * @returns Script script details
+     * @throws ApiError
+     */
+    static deleteScriptByHash({ workspace, hash, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/scripts/delete/h/{hash}',
+            path: {
+                'workspace': workspace,
+                'hash': hash,
+            },
+        });
+    }
+    /**
+     * delete all scripts at a given path (require admin)
+     * @returns string script path
+     * @throws ApiError
+     */
+    static deleteScriptByPath({ workspace, path, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/scripts/delete/p/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * get script by path
+     * @returns Script script details
+     * @throws ApiError
+     */
+    static getScriptByPath({ workspace, path, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/scripts/get/p/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * get script by path with draft
+     * @returns NewScriptWithDraft script details
+     * @throws ApiError
+     */
+    static getScriptByPathWithDraft({ workspace, path, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/scripts/get/draft/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * raw script by path
+     * @returns string script content
+     * @throws ApiError
+     */
+    static rawScriptByPath({ workspace, path, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/scripts/raw/p/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * raw script by path with a token (mostly used by lsp to be used with import maps to resolve scripts)
+     * @returns string script content
+     * @throws ApiError
+     */
+    static rawScriptByPathTokened({ workspace, token, path, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/scripts_u/tokened_raw/{workspace}/{token}/{path}',
+            path: {
+                'workspace': workspace,
+                'token': token,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * exists script by path
+     * @returns boolean does it exists
+     * @throws ApiError
+     */
+    static existsScriptByPath({ workspace, path, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/scripts/exists/p/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * get script by hash
+     * @returns Script script details
+     * @throws ApiError
+     */
+    static getScriptByHash({ workspace, hash, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/scripts/get/h/{hash}',
+            path: {
+                'workspace': workspace,
+                'hash': hash,
+            },
+        });
+    }
+    /**
+     * raw script by hash
+     * @returns string script content
+     * @throws ApiError
+     */
+    static rawScriptByHash({ workspace, path, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/scripts/raw/h/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * get script deployment status
+     * @returns any script details
+     * @throws ApiError
+     */
+    static getScriptDeploymentStatus({ workspace, hash, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/scripts/deployment_status/h/{hash}',
+            path: {
+                'workspace': workspace,
+                'hash': hash,
+            },
+        });
+    }
+}
+exports.ScriptService = ScriptService;

package/dist/services/SettingsService.d.ts

@@ -0,0 +1,15 @@
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class SettingsService {
+    /**
+     * get backend version
+     * @returns string git version of backend
+     * @throws ApiError
+     */
+    static backendVersion(): CancelablePromise<string>;
+    /**
+     * get openapi yaml spec
+     * @returns string openapi yaml file content
+     * @throws ApiError
+     */
+    static getOpenApiYaml(): CancelablePromise<string>;
+}

package/dist/services/SettingsService.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsService = void 0;
+const OpenAPI_1 = require("../core/OpenAPI");
+const request_1 = require("../core/request");
+class SettingsService {
+    /**
+     * get backend version
+     * @returns string git version of backend
+     * @throws ApiError
+     */
+    static backendVersion() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/version',
+        });
+    }
+    /**
+     * get openapi yaml spec
+     * @returns string openapi yaml file content
+     * @throws ApiError
+     */
+    static getOpenApiYaml() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/openapi.yaml',
+        });
+    }
+}
+exports.SettingsService = SettingsService;

package/dist/services/UserService.d.ts

@@ -0,0 +1,284 @@
+import type { EditWorkspaceUser } from '../models/EditWorkspaceUser';
+import type { GlobalUserInfo } from '../models/GlobalUserInfo';
+import type { Login } from '../models/Login';
+import type { NewToken } from '../models/NewToken';
+import type { NewTokenImpersonate } from '../models/NewTokenImpersonate';
+import type { NewUser } from '../models/NewUser';
+import type { TruncatedToken } from '../models/TruncatedToken';
+import type { User } from '../models/User';
+import type { WorkspaceInvite } from '../models/WorkspaceInvite';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class UserService {
+    /**
+     * login with password
+     * @returns string Successfully authenticated. The session ID is returned in a cookie named `token` and as plaintext response. Preferred method of authorization is through the bearer token. The cookie is only for browser convenience.
+     *
+     * @throws ApiError
+     */
+    static login({ requestBody, }: {
+        /**
+         * credentials
+         */
+        requestBody: Login;
+    }): CancelablePromise<string>;
+    /**
+     * logout
+     * @returns string clear cookies and clear token (if applicable)
+     * @throws ApiError
+     */
+    static logout(): CancelablePromise<string>;
+    /**
+     * create user (require admin privilege)
+     * @returns string user created
+     * @throws ApiError
+     */
+    static createUser({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * new user
+         */
+        requestBody: NewUser;
+    }): CancelablePromise<string>;
+    /**
+     * update user (require admin privilege)
+     * @returns string edited user
+     * @throws ApiError
+     */
+    static updateUser({ workspace, username, requestBody, }: {
+        workspace: string;
+        username: string;
+        /**
+         * new user
+         */
+        requestBody: EditWorkspaceUser;
+    }): CancelablePromise<string>;
+    /**
+     * is owner of path
+     * @returns boolean is owner
+     * @throws ApiError
+     */
+    static isOwnerOfPath({ workspace, path, }: {
+        workspace: string;
+        path: string;
+    }): CancelablePromise<boolean>;
+    /**
+     * set password
+     * @returns string password set
+     * @throws ApiError
+     */
+    static setPassword({ requestBody, }: {
+        /**
+         * set password
+         */
+        requestBody: {
+            password: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * create user
+     * @returns string user created
+     * @throws ApiError
+     */
+    static createUserGlobally({ requestBody, }: {
+        /**
+         * user info
+         */
+        requestBody: {
+            email: string;
+            password: string;
+            super_admin: boolean;
+            name?: string;
+            company?: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * global update user (require super admin)
+     * @returns string user updated
+     * @throws ApiError
+     */
+    static globalUserUpdate({ email, requestBody, }: {
+        email: string;
+        /**
+         * new user info
+         */
+        requestBody: {
+            is_super_admin?: boolean;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * global delete user (require super admin)
+     * @returns string user deleted
+     * @throws ApiError
+     */
+    static globalUserDelete({ email, }: {
+        email: string;
+    }): CancelablePromise<string>;
+    /**
+     * delete user (require admin privilege)
+     * @returns string delete user
+     * @throws ApiError
+     */
+    static deleteUser({ workspace, username, }: {
+        workspace: string;
+        username: string;
+    }): CancelablePromise<string>;
+    /**
+     * get current user email (if logged in)
+     * @returns string user email
+     * @throws ApiError
+     */
+    static getCurrentEmail(): CancelablePromise<string>;
+    /**
+     * get current usage outside of premium workspaces
+     * @returns number free usage
+     * @throws ApiError
+     */
+    static getUsage(): CancelablePromise<number>;
+    /**
+     * get current global whoami (if logged in)
+     * @returns GlobalUserInfo user email
+     * @throws ApiError
+     */
+    static globalWhoami(): CancelablePromise<GlobalUserInfo>;
+    /**
+     * list all workspace invites
+     * @returns WorkspaceInvite list all workspace invites
+     * @throws ApiError
+     */
+    static listWorkspaceInvites(): CancelablePromise<Array<WorkspaceInvite>>;
+    /**
+     * whoami
+     * @returns User user
+     * @throws ApiError
+     */
+    static whoami({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<User>;
+    /**
+     * leave workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    static leaveWorkspace({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<string>;
+    /**
+     * accept invite to workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    static acceptInvite({ requestBody, }: {
+        /**
+         * accept invite
+         */
+        requestBody: {
+            workspace_id: string;
+            username: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * decline invite to workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    static declineInvite({ requestBody, }: {
+        /**
+         * decline invite
+         */
+        requestBody: {
+            workspace_id: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * whois
+     * @returns User user
+     * @throws ApiError
+     */
+    static whois({ workspace, username, }: {
+        workspace: string;
+        username: string;
+    }): CancelablePromise<User>;
+    /**
+     * list all users as super admin (require to be super amdin)
+     * @returns GlobalUserInfo user
+     * @throws ApiError
+     */
+    static listUsersAsSuperAdmin({ 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<GlobalUserInfo>>;
+    /**
+     * list users
+     * @returns User user
+     * @throws ApiError
+     */
+    static listUsers({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<Array<User>>;
+    /**
+     * list usernames
+     * @returns string user
+     * @throws ApiError
+     */
+    static listUsernames({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<Array<string>>;
+    /**
+     * create token
+     * @returns string token created
+     * @throws ApiError
+     */
+    static createToken({ requestBody, }: {
+        /**
+         * new token
+         */
+        requestBody: NewToken;
+    }): CancelablePromise<string>;
+    /**
+     * create token to impersonate a user (require superadmin)
+     * @returns string token created
+     * @throws ApiError
+     */
+    static createTokenImpersonate({ requestBody, }: {
+        /**
+         * new token
+         */
+        requestBody: NewTokenImpersonate;
+    }): CancelablePromise<string>;
+    /**
+     * delete token
+     * @returns string delete token
+     * @throws ApiError
+     */
+    static deleteToken({ tokenPrefix, }: {
+        tokenPrefix: string;
+    }): CancelablePromise<string>;
+    /**
+     * list token
+     * @returns TruncatedToken truncated token
+     * @throws ApiError
+     */
+    static listTokens(): CancelablePromise<Array<TruncatedToken>>;
+    /**
+     * login with oauth authorization flow
+     * @returns string Successfully authenticated. The session ID is returned in a cookie named `token` and as plaintext response. Preferred method of authorization is through the bearer token. The cookie is only for browser convenience.
+     *
+     * @throws ApiError
+     */
+    static loginWithOauth({ clientName, requestBody, }: {
+        clientName: string;
+        /**
+         * Partially filled script
+         */
+        requestBody: {
+            code?: string;
+            state?: string;
+        };
+    }): CancelablePromise<string>;
+}