windmill-components 1.13.0

package/gen/services/ScriptService.d.ts

@@ -0,0 +1,165 @@
+import type { MainArgSignature } from '../models/MainArgSignature';
+import type { Script } from '../models/Script';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class ScriptService {
+    /**
+     * list all available hub scripts
+     * @returns any hub scripts list
+     * @throws ApiError
+     */
+    static listHubScripts(): CancelablePromise<Array<{
+        id: number;
+        summary: string;
+        app: string;
+        approved: boolean;
+    }>>;
+    /**
+     * get hub script content by path
+     * @returns string script details
+     * @throws ApiError
+     */
+    static getHubScriptContentByPath({ path, }: {
+        path: string;
+    }): CancelablePromise<string>;
+    /**
+     * 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, }: {
+        workspace: string;
+        /** 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;
+        /** order by desc order (default true) **/
+        orderDesc?: boolean;
+        /** mask to filter exact matching user creator **/
+        createdBy?: string;
+        /** mask to filter matching starting parh **/
+        pathStart?: string;
+        /** mask to filter exact matching path **/
+        pathExact?: string;
+        /** mask to filter scripts whom first direct parent has exact hash **/
+        firstParentHash?: string;
+        /** mask to filter scripts whom last parent in the chain has exact hash.
+         * Beware that each script stores only a limited number of parents. Hence
+         * the last parent hash for a script is not necessarily its top-most parent.
+         * To find the top-most parent you will have to jump from last to last hash
+         * until finding the parent
+         *  **/
+        lastParentHash?: string;
+        /** is the hash present in the array of stored parent hashes for this script.
+         * The same warning applies than for last_parent_hash. A script only store a
+         * limited number of direct parent
+         *  **/
+        parentHash?: string;
+        /** (default false)
+         * show also the archived files.
+         * when multiple archived hash share the same path, only the ones with the latest create_at
+         * are displayed.
+         *  **/
+        showArchived?: boolean;
+        /** (default regardless)
+         * if true show only the templates
+         * if false show only the non templates
+         * if not defined, show all regardless of if the script is a template
+         *  **/
+        isTemplate?: boolean;
+    }): CancelablePromise<Array<Script>>;
+    /**
+     * create script
+     * @returns string script created
+     * @throws ApiError
+     */
+    static createScript({ workspace, requestBody, }: {
+        workspace: string;
+        /** Partially filled script **/
+        requestBody: {
+            path: string;
+            parent_hash?: string;
+            summary: string;
+            description: string;
+            content: string;
+            schema?: any;
+            is_template?: boolean;
+            lock?: Array<string>;
+            language: 'python3' | 'deno';
+        };
+    }): CancelablePromise<string>;
+    /**
+     * inspect python code to infer jsonschema of arguments
+     * @returns MainArgSignature parsed args
+     * @throws ApiError
+     */
+    static pythonToJsonschema({ requestBody, }: {
+        /** python code with the main function **/
+        requestBody: string;
+    }): CancelablePromise<MainArgSignature>;
+    /**
+     * inspect deno code to infer jsonschema of arguments
+     * @returns MainArgSignature parsed args
+     * @throws ApiError
+     */
+    static denoToJsonschema({ requestBody, }: {
+        /** deno code with the main function **/
+        requestBody: string;
+    }): CancelablePromise<MainArgSignature>;
+    /**
+     * archive script by path
+     * @returns string script archived
+     * @throws ApiError
+     */
+    static archiveScriptByPath({ workspace, path, }: {
+        workspace: string;
+        path: string;
+    }): CancelablePromise<string>;
+    /**
+     * archive script by hash
+     * @returns Script script details
+     * @throws ApiError
+     */
+    static archiveScriptByHash({ workspace, hash, }: {
+        workspace: string;
+        hash: string;
+    }): CancelablePromise<Script>;
+    /**
+     * delete script by hash (erase content but keep hash)
+     * @returns Script script details
+     * @throws ApiError
+     */
+    static deleteScriptByHash({ workspace, hash, }: {
+        workspace: string;
+        hash: string;
+    }): CancelablePromise<Script>;
+    /**
+     * get script by path
+     * @returns Script script details
+     * @throws ApiError
+     */
+    static getScriptByPath({ workspace, path, }: {
+        workspace: string;
+        path: string;
+    }): CancelablePromise<Script>;
+    /**
+     * get script by hash
+     * @returns Script script details
+     * @throws ApiError
+     */
+    static getScriptByHash({ workspace, hash, }: {
+        workspace: string;
+        hash: string;
+    }): CancelablePromise<Script>;
+    /**
+     * get script deployment status
+     * @returns any script details
+     * @throws ApiError
+     */
+    static getScriptDeploymentStatus({ workspace, hash, }: {
+        workspace: string;
+        hash: string;
+    }): CancelablePromise<{
+        lock?: string;
+        lock_error_logs?: string;
+    }>;
+}

package/gen/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/gen/services/UserService.d.ts

@@ -0,0 +1,211 @@
+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 { 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, }: {
+        /** Partially filled script **/
+        requestBody: Login;
+    }): 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>;
+    /**
+     * 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>;
+    /**
+     * delete user (require admin privilege)
+     * @returns string delete user
+     * @throws ApiError
+     */
+    static deleteUser({ workspace, username, }: {
+        workspace: string;
+        username: string;
+    }): CancelablePromise<string>;
+    /**
+     * logout
+     * @returns string logout
+     * @throws ApiError
+     */
+    static logout(): CancelablePromise<string>;
+    /**
+     * get current user email (if logged in)
+     * @returns string user email
+     * @throws ApiError
+     */
+    static getCurrentEmail(): CancelablePromise<string>;
+    /**
+     * 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>;
+    /**
+     * 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>>;
+}

package/gen/services/VariableService.d.ts

@@ -0,0 +1,66 @@
+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, }: {
+        workspace: string;
+        /** new variable **/
+        requestBody: CreateVariable;
+    }): 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, }: {
+        workspace: string;
+        path: string;
+        /** updated variable **/
+        requestBody: EditVariable;
+    }): 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>;
+    /**
+     * 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/gen/services/WorkerService.d.ts

@@ -0,0 +1,15 @@
+import type { WorkerPing } from '../models/WorkerPing';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class WorkerService {
+    /**
+     * 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/gen/services/WorkspaceService.d.ts

@@ -0,0 +1,137 @@
+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>>;
+    /**
+     * 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 amdin)
+     * @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>;
+    /**
+     * validate id
+     * @returns string status
+     * @throws ApiError
+     */
+    static validateId({ requestBody, }: {
+        /** id of workspace **/
+        requestBody: {
+            id: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * validate username
+     * @returns string status
+     * @throws ApiError
+     */
+    static validateUsername({ requestBody, }: {
+        requestBody: {
+            id: string;
+            username: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * invite user to workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    static inviteUser({ workspace, requestBody, }: {
+        workspace: string;
+        /** WorkspaceInvite **/
+        requestBody: {
+            email: string;
+            is_admin: boolean;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * delete user invite
+     * @returns string status
+     * @throws ApiError
+     */
+    static deleteInvite({ workspace, requestBody, }: {
+        workspace: string;
+        /** WorkspaceInvite **/
+        requestBody: {
+            email: string;
+            is_admin: boolean;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * delete workspace
+     * @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;
+    }>;
+    /**
+     * edit slack command
+     * @returns string status
+     * @throws ApiError
+     */
+    static editSlackCommand({ workspace, requestBody, }: {
+        workspace: string;
+        /** WorkspaceInvite **/
+        requestBody: {
+            slack_command_script?: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * disconnect client
+     * @returns string disconnected client
+     * @throws ApiError
+     */
+    static disconnectClient({ workspace, clientName, }: {
+        workspace: string;
+        clientName: string;
+    }): CancelablePromise<string>;
+}

package/infer.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from './common';
+export declare function inferArgs(language: 'python3' | 'deno', code: string, schema: Schema): Promise<void>;

package/lib/components/ArgInfo.svelte.d.ts

@@ -0,0 +1,16 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        value: any;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ArgInfoProps = typeof __propDef.props;
+export declare type ArgInfoEvents = typeof __propDef.events;
+export declare type ArgInfoSlots = typeof __propDef.slots;
+export default class ArgInfo extends SvelteComponentTyped<ArgInfoProps, ArgInfoEvents, ArgInfoSlots> {
+}
+export {};

package/lib/components/ArgInput.svelte.d.ts

@@ -0,0 +1,37 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        label?: string | undefined;
+        value: any;
+        defaultValue?: any;
+        description?: string | undefined;
+        format?: string | undefined;
+        contentEncoding?: string | undefined;
+        type?: string | undefined;
+        required?: boolean | undefined;
+        pattern: undefined | string;
+        valid?: boolean | undefined;
+        minRows?: number | undefined;
+        maxRows?: number | undefined;
+        enum_?: string[] | undefined;
+        disabled?: boolean | undefined;
+        editableSchema?: boolean | undefined;
+        itemsType?: {
+            type?: "string" | "number" | undefined;
+            contentEncoding?: string | undefined;
+        } | undefined;
+        displayHeader?: boolean | undefined;
+        evalValueToRaw?: (() => void) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type ArgInputProps = typeof __propDef.props;
+export declare type ArgInputEvents = typeof __propDef.events;
+export declare type ArgInputSlots = typeof __propDef.slots;
+export default class ArgInput extends SvelteComponentTyped<ArgInputProps, ArgInputEvents, ArgInputSlots> {
+    get evalValueToRaw(): () => void;
+}
+export {};

package/lib/components/AutosizedTextarea.svelte.d.ts

@@ -0,0 +1,19 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        value: string;
+        placeholder?: string | undefined;
+        minRows?: number | undefined;
+        maxRows?: number | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export declare type AutosizedTextareaProps = typeof __propDef.props;
+export declare type AutosizedTextareaEvents = typeof __propDef.events;
+export declare type AutosizedTextareaSlots = typeof __propDef.slots;
+export default class AutosizedTextarea extends SvelteComponentTyped<AutosizedTextareaProps, AutosizedTextareaEvents, AutosizedTextareaSlots> {
+}
+export {};