windmill-client 0.1.0

package/src/services/FavoriteService.ts

@@ -0,0 +1,62 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+
+export class FavoriteService {
+
+    /**
+     * star item
+     * @returns any star item
+     * @throws ApiError
+     */
+    public static star({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        requestBody?: {
+            path?: string;
+            favorite_kind?: 'flow' | 'app' | 'script';
+        },
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/favorites/star',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * unstar item
+     * @returns any unstar item
+     * @throws ApiError
+     */
+    public static unstar({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        requestBody?: {
+            path?: string;
+            favorite_kind?: 'flow' | 'app' | 'script';
+        },
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/favorites/unstar',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+}

package/src/services/FlowService.ts

@@ -0,0 +1,368 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+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';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+
+export class FlowService {
+
+    /**
+     * list all available hub flows
+     * @returns any hub flows list
+     * @throws ApiError
+     */
+    public static listHubFlows(): CancelablePromise<{
+        flows?: Array<{
+            id: number;
+            flow_id: number;
+            summary: string;
+            apps: Array<string>;
+            approved: boolean;
+            votes: number;
+        }>;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/flows/hub/list',
+        });
+    }
+
+    /**
+     * get hub flow by id
+     * @returns any flow
+     * @throws ApiError
+     */
+    public static getHubFlowById({
+        id,
+    }: {
+        id: number,
+    }): CancelablePromise<{
+        flow?: OpenFlow;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/flows/hub/get/{id}',
+            path: {
+                'id': id,
+            },
+        });
+    }
+
+    /**
+     * list all available flow paths
+     * @returns string list of flow paths
+     * @throws ApiError
+     */
+    public static listFlowPaths({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<Array<string>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/flows/list_paths',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * list all available flows
+     * @returns any All available flow
+     * @throws ApiError
+     */
+    public 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;
+    })>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/flows/list',
+            path: {
+                'workspace': workspace,
+            },
+            query: {
+                'page': page,
+                'per_page': perPage,
+                'order_desc': orderDesc,
+                'created_by': createdBy,
+                'path_start': pathStart,
+                'path_exact': pathExact,
+                'show_archived': showArchived,
+                'starred_only': starredOnly,
+            },
+        });
+    }
+
+    /**
+     * get flow by path
+     * @returns Flow flow details
+     * @throws ApiError
+     */
+    public static getFlowByPath({
+        workspace,
+        path,
+    }: {
+        workspace: string,
+        path: string,
+    }): CancelablePromise<Flow> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/flows/get/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+
+    /**
+     * get flow by path with draft
+     * @returns any flow details with draft
+     * @throws ApiError
+     */
+    public static getFlowByPathWithDraft({
+        workspace,
+        path,
+    }: {
+        workspace: string,
+        path: string,
+    }): CancelablePromise<(Flow & {
+        draft?: Flow;
+    })> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/flows/get/draft/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+
+    /**
+     * exists flow by path
+     * @returns boolean flow details
+     * @throws ApiError
+     */
+    public static existsFlowByPath({
+        workspace,
+        path,
+    }: {
+        workspace: string,
+        path: string,
+    }): CancelablePromise<boolean> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/flows/exists/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+
+    /**
+     * create flow
+     * @returns string flow created
+     * @throws ApiError
+     */
+    public static createFlow({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        /**
+         * Partially filled flow
+         */
+        requestBody: (OpenFlowWPath & {
+            draft_only?: boolean;
+        }),
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/flows/create',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * update flow
+     * @returns string flow updated
+     * @throws ApiError
+     */
+    public static updateFlow({
+        workspace,
+        path,
+        requestBody,
+    }: {
+        workspace: string,
+        path: string,
+        /**
+         * Partially filled flow
+         */
+        requestBody: OpenFlowWPath,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/flows/update/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * archive flow by path
+     * @returns string flow archived
+     * @throws ApiError
+     */
+    public static archiveFlowByPath({
+        workspace,
+        path,
+        requestBody,
+    }: {
+        workspace: string,
+        path: string,
+        /**
+         * archiveFlow
+         */
+        requestBody: {
+            archived?: boolean;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/flows/archive/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * delete flow by path
+     * @returns string flow delete
+     * @throws ApiError
+     */
+    public static deleteFlowByPath({
+        workspace,
+        path,
+    }: {
+        workspace: string,
+        path: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/w/{workspace}/flows/delete/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+
+    /**
+     * list inputs for previous completed flow jobs
+     * @returns Input input history for completed jobs with this flow path
+     * @throws ApiError
+     */
+    public 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>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/flows/input_history/p/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            query: {
+                'page': page,
+                'per_page': perPage,
+            },
+        });
+    }
+
+}

package/src/services/FolderService.ts

@@ -0,0 +1,269 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Folder } from '../models/Folder';
+
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+
+export class FolderService {
+
+    /**
+     * list folders
+     * @returns Folder folder list
+     * @throws ApiError
+     */
+    public 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>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/folders/list',
+            path: {
+                'workspace': workspace,
+            },
+            query: {
+                'page': page,
+                'per_page': perPage,
+            },
+        });
+    }
+
+    /**
+     * list folder names
+     * @returns string folder list
+     * @throws ApiError
+     */
+    public static listFolderNames({
+        workspace,
+        onlyMemberOf,
+    }: {
+        workspace: string,
+        /**
+         * only list the folders the user is member of (default false)
+         */
+        onlyMemberOf?: boolean,
+    }): CancelablePromise<Array<string>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/folders/listnames',
+            path: {
+                'workspace': workspace,
+            },
+            query: {
+                'only_member_of': onlyMemberOf,
+            },
+        });
+    }
+
+    /**
+     * create folder
+     * @returns string folder created
+     * @throws ApiError
+     */
+    public static createFolder({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        /**
+         * create folder
+         */
+        requestBody: {
+            name: string;
+            owners?: Array<string>;
+            extra_perms?: any;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/folders/create',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * update folder
+     * @returns string folder updated
+     * @throws ApiError
+     */
+    public static updateFolder({
+        workspace,
+        name,
+        requestBody,
+    }: {
+        workspace: string,
+        name: string,
+        /**
+         * update folder
+         */
+        requestBody: {
+            owners?: Array<string>;
+            extra_perms?: any;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/folders/update/{name}',
+            path: {
+                'workspace': workspace,
+                'name': name,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * delete folder
+     * @returns string folder deleted
+     * @throws ApiError
+     */
+    public static deleteFolder({
+        workspace,
+        name,
+    }: {
+        workspace: string,
+        name: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/w/{workspace}/folders/delete/{name}',
+            path: {
+                'workspace': workspace,
+                'name': name,
+            },
+        });
+    }
+
+    /**
+     * get folder
+     * @returns Folder folder
+     * @throws ApiError
+     */
+    public static getFolder({
+        workspace,
+        name,
+    }: {
+        workspace: string,
+        name: string,
+    }): CancelablePromise<Folder> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/folders/get/{name}',
+            path: {
+                'workspace': workspace,
+                'name': name,
+            },
+        });
+    }
+
+    /**
+     * get folder usage
+     * @returns any folder
+     * @throws ApiError
+     */
+    public static getFolderUsage({
+        workspace,
+        name,
+    }: {
+        workspace: string,
+        name: string,
+    }): CancelablePromise<{
+        scripts: number;
+        flows: number;
+        apps: number;
+        resources: number;
+        variables: number;
+        schedules: number;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/folders/getusage/{name}',
+            path: {
+                'workspace': workspace,
+                'name': name,
+            },
+        });
+    }
+
+    /**
+     * add owner to folder
+     * @returns string owner added to folder
+     * @throws ApiError
+     */
+    public static addOwnerToFolder({
+        workspace,
+        name,
+        requestBody,
+    }: {
+        workspace: string,
+        name: string,
+        /**
+         * owner user to folder
+         */
+        requestBody: {
+            owner?: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/folders/addowner/{name}',
+            path: {
+                'workspace': workspace,
+                'name': name,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * remove owner to folder
+     * @returns string owner removed from folder
+     * @throws ApiError
+     */
+    public static removeOwnerToFolder({
+        workspace,
+        name,
+        requestBody,
+    }: {
+        workspace: string,
+        name: string,
+        /**
+         * added owner to folder
+         */
+        requestBody: {
+            owner?: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/folders/removeowner/{name}',
+            path: {
+                'workspace': workspace,
+                'name': name,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+}