windmill-client 0.1.0 → 0.2.1

package/src/services/FavoriteService.d.ts

@@ -0,0 +1,27 @@
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class FavoriteService {
+    /**
+     * star item
+     * @returns any star item
+     * @throws ApiError
+     */
+    static star({ workspace, requestBody, }: {
+        workspace: string;
+        requestBody?: {
+            path?: string;
+            favorite_kind?: 'flow' | 'app' | 'script';
+        };
+    }): CancelablePromise<any>;
+    /**
+     * unstar item
+     * @returns any unstar item
+     * @throws ApiError
+     */
+    static unstar({ workspace, requestBody, }: {
+        workspace: string;
+        requestBody?: {
+            path?: string;
+            favorite_kind?: 'flow' | 'app' | 'script';
+        };
+    }): CancelablePromise<any>;
+}

package/src/services/FlowService.d.ts

@@ -0,0 +1,186 @@
+import type { Flow } from '../models/Flow';
+import type { Input } from '../models/Input';
+import type { OpenFlow } from '../models/OpenFlow';
+import type { OpenFlowWPath } from '../models/OpenFlowWPath';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class FlowService {
+    /**
+     * list all available hub flows
+     * @returns any hub flows list
+     * @throws ApiError
+     */
+    static listHubFlows(): CancelablePromise<{
+        flows?: Array<{
+            id: number;
+            flow_id: number;
+            summary: string;
+            apps: Array<string>;
+            approved: boolean;
+            votes: number;
+        }>;
+    }>;
+    /**
+     * get hub flow by id
+     * @returns any flow
+     * @throws ApiError
+     */
+    static getHubFlowById({ id, }: {
+        id: number;
+    }): CancelablePromise<{
+        flow?: OpenFlow;
+    }>;
+    /**
+     * list all available flow paths
+     * @returns string list of flow paths
+     * @throws ApiError
+     */
+    static listFlowPaths({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<Array<string>>;
+    /**
+     * list all available flows
+     * @returns any All available flow
+     * @throws ApiError
+     */
+    static listFlows({ workspace, page, perPage, orderDesc, createdBy, pathStart, pathExact, showArchived, starredOnly, }: {
+        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 path
+         */
+        pathStart?: string;
+        /**
+         * mask to filter exact matching path
+         */
+        pathExact?: 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 false)
+         * show only the starred items
+         *
+         */
+        starredOnly?: boolean;
+    }): CancelablePromise<Array<(Flow & {
+        has_draft?: boolean;
+        draft_only?: boolean;
+    })>>;
+    /**
+     * get flow by path
+     * @returns Flow flow details
+     * @throws ApiError
+     */
+    static getFlowByPath({ workspace, path, }: {
+        workspace: string;
+        path: string;
+    }): CancelablePromise<Flow>;
+    /**
+     * get flow by path with draft
+     * @returns any flow details with draft
+     * @throws ApiError
+     */
+    static getFlowByPathWithDraft({ workspace, path, }: {
+        workspace: string;
+        path: string;
+    }): CancelablePromise<(Flow & {
+        draft?: Flow;
+    })>;
+    /**
+     * exists flow by path
+     * @returns boolean flow details
+     * @throws ApiError
+     */
+    static existsFlowByPath({ workspace, path, }: {
+        workspace: string;
+        path: string;
+    }): CancelablePromise<boolean>;
+    /**
+     * create flow
+     * @returns string flow created
+     * @throws ApiError
+     */
+    static createFlow({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * Partially filled flow
+         */
+        requestBody: (OpenFlowWPath & {
+            draft_only?: boolean;
+        });
+    }): CancelablePromise<string>;
+    /**
+     * update flow
+     * @returns string flow updated
+     * @throws ApiError
+     */
+    static updateFlow({ workspace, path, requestBody, }: {
+        workspace: string;
+        path: string;
+        /**
+         * Partially filled flow
+         */
+        requestBody: OpenFlowWPath;
+    }): CancelablePromise<string>;
+    /**
+     * archive flow by path
+     * @returns string flow archived
+     * @throws ApiError
+     */
+    static archiveFlowByPath({ workspace, path, requestBody, }: {
+        workspace: string;
+        path: string;
+        /**
+         * archiveFlow
+         */
+        requestBody: {
+            archived?: boolean;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * delete flow by path
+     * @returns string flow delete
+     * @throws ApiError
+     */
+    static deleteFlowByPath({ workspace, path, }: {
+        workspace: string;
+        path: string;
+    }): CancelablePromise<string>;
+    /**
+     * list inputs for previous completed flow jobs
+     * @returns Input input history for completed jobs with this flow path
+     * @throws ApiError
+     */
+    static getFlowInputHistoryByPath({ workspace, path, page, perPage, }: {
+        workspace: string;
+        path: 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;
+    }): CancelablePromise<Array<Input>>;
+}

package/src/services/FolderService.d.ts

@@ -0,0 +1,128 @@
+import type { Folder } from '../models/Folder';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class FolderService {
+    /**
+     * list folders
+     * @returns Folder folder list
+     * @throws ApiError
+     */
+    static listFolders({ workspace, page, perPage, }: {
+        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;
+    }): CancelablePromise<Array<Folder>>;
+    /**
+     * list folder names
+     * @returns string folder list
+     * @throws ApiError
+     */
+    static listFolderNames({ workspace, onlyMemberOf, }: {
+        workspace: string;
+        /**
+         * only list the folders the user is member of (default false)
+         */
+        onlyMemberOf?: boolean;
+    }): CancelablePromise<Array<string>>;
+    /**
+     * create folder
+     * @returns string folder created
+     * @throws ApiError
+     */
+    static createFolder({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * create folder
+         */
+        requestBody: {
+            name: string;
+            owners?: Array<string>;
+            extra_perms?: any;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * update folder
+     * @returns string folder updated
+     * @throws ApiError
+     */
+    static updateFolder({ workspace, name, requestBody, }: {
+        workspace: string;
+        name: string;
+        /**
+         * update folder
+         */
+        requestBody: {
+            owners?: Array<string>;
+            extra_perms?: any;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * delete folder
+     * @returns string folder deleted
+     * @throws ApiError
+     */
+    static deleteFolder({ workspace, name, }: {
+        workspace: string;
+        name: string;
+    }): CancelablePromise<string>;
+    /**
+     * get folder
+     * @returns Folder folder
+     * @throws ApiError
+     */
+    static getFolder({ workspace, name, }: {
+        workspace: string;
+        name: string;
+    }): CancelablePromise<Folder>;
+    /**
+     * get folder usage
+     * @returns any folder
+     * @throws ApiError
+     */
+    static getFolderUsage({ workspace, name, }: {
+        workspace: string;
+        name: string;
+    }): CancelablePromise<{
+        scripts: number;
+        flows: number;
+        apps: number;
+        resources: number;
+        variables: number;
+        schedules: number;
+    }>;
+    /**
+     * add owner to folder
+     * @returns string owner added to folder
+     * @throws ApiError
+     */
+    static addOwnerToFolder({ workspace, name, requestBody, }: {
+        workspace: string;
+        name: string;
+        /**
+         * owner user to folder
+         */
+        requestBody: {
+            owner?: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * remove owner to folder
+     * @returns string owner removed from folder
+     * @throws ApiError
+     */
+    static removeOwnerToFolder({ workspace, name, requestBody, }: {
+        workspace: string;
+        name: string;
+        /**
+         * added owner to folder
+         */
+        requestBody: {
+            owner?: string;
+        };
+    }): CancelablePromise<string>;
+}

package/src/services/GranularAclService.d.ts

@@ -0,0 +1,46 @@
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class GranularAclService {
+    /**
+     * get granular acls
+     * @returns boolean acls
+     * @throws ApiError
+     */
+    static getGranularAcls({ workspace, path, kind, }: {
+        workspace: string;
+        path: string;
+        kind: 'script' | 'group_' | 'resource' | 'schedule' | 'variable' | 'flow' | 'folder' | 'app';
+    }): CancelablePromise<Record<string, boolean>>;
+    /**
+     * add granular acls
+     * @returns string granular acl added
+     * @throws ApiError
+     */
+    static addGranularAcls({ workspace, path, kind, requestBody, }: {
+        workspace: string;
+        path: string;
+        kind: 'script' | 'group_' | 'resource' | 'schedule' | 'variable' | 'flow' | 'folder' | 'app';
+        /**
+         * acl to add
+         */
+        requestBody: {
+            owner: string;
+            write?: boolean;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * remove granular acls
+     * @returns string granular acl removed
+     * @throws ApiError
+     */
+    static removeGranularAcls({ workspace, path, kind, requestBody, }: {
+        workspace: string;
+        path: string;
+        kind: 'script' | 'group_' | 'resource' | 'schedule' | 'variable' | 'flow' | 'folder' | 'app';
+        /**
+         * acl to add
+         */
+        requestBody: {
+            owner: string;
+        };
+    }): CancelablePromise<string>;
+}

package/src/services/GroupService.d.ts

@@ -0,0 +1,110 @@
+import type { Group } from '../models/Group';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class GroupService {
+    /**
+     * list groups
+     * @returns Group group list
+     * @throws ApiError
+     */
+    static listGroups({ workspace, page, perPage, }: {
+        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;
+    }): CancelablePromise<Array<Group>>;
+    /**
+     * list group names
+     * @returns string group list
+     * @throws ApiError
+     */
+    static listGroupNames({ workspace, onlyMemberOf, }: {
+        workspace: string;
+        /**
+         * only list the groups the user is member of (default false)
+         */
+        onlyMemberOf?: boolean;
+    }): CancelablePromise<Array<string>>;
+    /**
+     * create group
+     * @returns string group created
+     * @throws ApiError
+     */
+    static createGroup({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * create group
+         */
+        requestBody: {
+            name: string;
+            summary?: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * update group
+     * @returns string group updated
+     * @throws ApiError
+     */
+    static updateGroup({ workspace, name, requestBody, }: {
+        workspace: string;
+        name: string;
+        /**
+         * updated group
+         */
+        requestBody: {
+            summary?: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * delete group
+     * @returns string group deleted
+     * @throws ApiError
+     */
+    static deleteGroup({ workspace, name, }: {
+        workspace: string;
+        name: string;
+    }): CancelablePromise<string>;
+    /**
+     * get group
+     * @returns Group group
+     * @throws ApiError
+     */
+    static getGroup({ workspace, name, }: {
+        workspace: string;
+        name: string;
+    }): CancelablePromise<Group>;
+    /**
+     * add user to group
+     * @returns string user added to group
+     * @throws ApiError
+     */
+    static addUserToGroup({ workspace, name, requestBody, }: {
+        workspace: string;
+        name: string;
+        /**
+         * added user to group
+         */
+        requestBody: {
+            username?: string;
+        };
+    }): CancelablePromise<string>;
+    /**
+     * remove user to group
+     * @returns string user removed from group
+     * @throws ApiError
+     */
+    static removeUserToGroup({ workspace, name, requestBody, }: {
+        workspace: string;
+        name: string;
+        /**
+         * added user to group
+         */
+        requestBody: {
+            username?: string;
+        };
+    }): CancelablePromise<string>;
+}

package/src/services/InputService.d.ts

@@ -0,0 +1,78 @@
+import type { CreateInput } from '../models/CreateInput';
+import type { Input } from '../models/Input';
+import type { RunnableType } from '../models/RunnableType';
+import type { UpdateInput } from '../models/UpdateInput';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class InputService {
+    /**
+     * List Inputs used in previously completed jobs
+     * @returns Input Input history for completed jobs
+     * @throws ApiError
+     */
+    static getInputHistory({ workspace, runnableId, runnableType, page, perPage, }: {
+        workspace: string;
+        runnableId?: string;
+        runnableType?: RunnableType;
+        /**
+         * 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<Input>>;
+    /**
+     * List saved Inputs for a Runnable
+     * @returns Input Saved Inputs for a Runnable
+     * @throws ApiError
+     */
+    static listInputs({ workspace, runnableId, runnableType, page, perPage, }: {
+        workspace: string;
+        runnableId?: string;
+        runnableType?: RunnableType;
+        /**
+         * 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<Input>>;
+    /**
+     * Create an Input for future use in a script or flow
+     * @returns string Input created
+     * @throws ApiError
+     */
+    static createInput({ workspace, requestBody, runnableId, runnableType, }: {
+        workspace: string;
+        /**
+         * Input
+         */
+        requestBody: CreateInput;
+        runnableId?: string;
+        runnableType?: RunnableType;
+    }): CancelablePromise<string>;
+    /**
+     * Update an Input
+     * @returns string Input updated
+     * @throws ApiError
+     */
+    static updateInput({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * UpdateInput
+         */
+        requestBody: UpdateInput;
+    }): CancelablePromise<string>;
+    /**
+     * Delete a Saved Input
+     * @returns string Input deleted
+     * @throws ApiError
+     */
+    static deleteInput({ workspace, input, }: {
+        workspace: string;
+        input: string;
+    }): CancelablePromise<string>;
+}