windmill-client 0.3.5 → 0.3.7

package/src/services/FlowService.ts

@@ -1,369 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* 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

@@ -1,270 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* 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',
-        });
-    }
-
-}