windmill-client 0.3.5 → 0.3.6

package/src/services/ResourceService.ts

@@ -1,401 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { CreateResource } from '../models/CreateResource';
-import type { EditResource } from '../models/EditResource';
-import type { EditResourceType } from '../models/EditResourceType';
-import type { ListableResource } from '../models/ListableResource';
-import type { Resource } from '../models/Resource';
-import type { ResourceType } from '../models/ResourceType';
-
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-
-export class ResourceService {
-
-    /**
-     * create resource
-     * @returns string resource created
-     * @throws ApiError
-     */
-    public static createResource({
-        workspace,
-        requestBody,
-        updateIfExists,
-    }: {
-        workspace: string,
-        /**
-         * new resource
-         */
-        requestBody: CreateResource,
-        updateIfExists?: boolean,
-    }): CancelablePromise<string> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/w/{workspace}/resources/create',
-            path: {
-                'workspace': workspace,
-            },
-            query: {
-                'update_if_exists': updateIfExists,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * delete resource
-     * @returns string resource deleted
-     * @throws ApiError
-     */
-    public static deleteResource({
-        workspace,
-        path,
-    }: {
-        workspace: string,
-        path: string,
-    }): CancelablePromise<string> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/w/{workspace}/resources/delete/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-        });
-    }
-
-    /**
-     * update resource
-     * @returns string resource updated
-     * @throws ApiError
-     */
-    public static updateResource({
-        workspace,
-        path,
-        requestBody,
-    }: {
-        workspace: string,
-        path: string,
-        /**
-         * updated resource
-         */
-        requestBody: EditResource,
-    }): CancelablePromise<string> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/w/{workspace}/resources/update/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * update resource value
-     * @returns string resource value updated
-     * @throws ApiError
-     */
-    public static updateResourceValue({
-        workspace,
-        path,
-        requestBody,
-    }: {
-        workspace: string,
-        path: string,
-        /**
-         * updated resource
-         */
-        requestBody: {
-            value?: any;
-        },
-    }): CancelablePromise<string> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/w/{workspace}/resources/update_value/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * get resource
-     * @returns Resource resource
-     * @throws ApiError
-     */
-    public static getResource({
-        workspace,
-        path,
-    }: {
-        workspace: string,
-        path: string,
-    }): CancelablePromise<Resource> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/w/{workspace}/resources/get/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-        });
-    }
-
-    /**
-     * get resource value
-     * @returns any resource value
-     * @throws ApiError
-     */
-    public static getResourceValue({
-        workspace,
-        path,
-    }: {
-        workspace: string,
-        path: string,
-    }): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/w/{workspace}/resources/get_value/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-        });
-    }
-
-    /**
-     * does resource exists
-     * @returns boolean does resource exists
-     * @throws ApiError
-     */
-    public static existsResource({
-        workspace,
-        path,
-    }: {
-        workspace: string,
-        path: string,
-    }): CancelablePromise<boolean> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/w/{workspace}/resources/exists/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-        });
-    }
-
-    /**
-     * list resources
-     * @returns ListableResource resource list
-     * @throws ApiError
-     */
-    public static listResource({
-        workspace,
-        page,
-        perPage,
-        resourceType,
-        resourceTypeExclude,
-    }: {
-        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,
-        /**
-         * resource_types to list from, separated by ',',
-         */
-        resourceType?: string,
-        /**
-         * resource_types to not list from, separated by ',',
-         */
-        resourceTypeExclude?: string,
-    }): CancelablePromise<Array<ListableResource>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/w/{workspace}/resources/list',
-            path: {
-                'workspace': workspace,
-            },
-            query: {
-                'page': page,
-                'per_page': perPage,
-                'resource_type': resourceType,
-                'resource_type_exclude': resourceTypeExclude,
-            },
-        });
-    }
-
-    /**
-     * create resource_type
-     * @returns string resource_type created
-     * @throws ApiError
-     */
-    public static createResourceType({
-        workspace,
-        requestBody,
-    }: {
-        workspace: string,
-        /**
-         * new resource_type
-         */
-        requestBody: ResourceType,
-    }): CancelablePromise<string> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/w/{workspace}/resources/type/create',
-            path: {
-                'workspace': workspace,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * delete resource_type
-     * @returns string resource_type deleted
-     * @throws ApiError
-     */
-    public static deleteResourceType({
-        workspace,
-        path,
-    }: {
-        workspace: string,
-        path: string,
-    }): CancelablePromise<string> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/w/{workspace}/resources/type/delete/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-        });
-    }
-
-    /**
-     * update resource_type
-     * @returns string resource_type updated
-     * @throws ApiError
-     */
-    public static updateResourceType({
-        workspace,
-        path,
-        requestBody,
-    }: {
-        workspace: string,
-        path: string,
-        /**
-         * updated resource_type
-         */
-        requestBody: EditResourceType,
-    }): CancelablePromise<string> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/w/{workspace}/resources/type/update/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * get resource_type
-     * @returns ResourceType resource_type deleted
-     * @throws ApiError
-     */
-    public static getResourceType({
-        workspace,
-        path,
-    }: {
-        workspace: string,
-        path: string,
-    }): CancelablePromise<ResourceType> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/w/{workspace}/resources/type/get/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-        });
-    }
-
-    /**
-     * does resource_type exists
-     * @returns boolean does resource_type exist
-     * @throws ApiError
-     */
-    public static existsResourceType({
-        workspace,
-        path,
-    }: {
-        workspace: string,
-        path: string,
-    }): CancelablePromise<boolean> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/w/{workspace}/resources/type/exists/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-        });
-    }
-
-    /**
-     * list resource_types
-     * @returns ResourceType resource_type list
-     * @throws ApiError
-     */
-    public static listResourceType({
-        workspace,
-    }: {
-        workspace: string,
-    }): CancelablePromise<Array<ResourceType>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/w/{workspace}/resources/type/list',
-            path: {
-                'workspace': workspace,
-            },
-        });
-    }
-
-    /**
-     * list resource_types names
-     * @returns string resource_type list
-     * @throws ApiError
-     */
-    public static listResourceTypeNames({
-        workspace,
-    }: {
-        workspace: string,
-    }): CancelablePromise<Array<string>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/w/{workspace}/resources/type/listnames',
-            path: {
-                'workspace': workspace,
-            },
-        });
-    }
-
-}

package/src/services/ScheduleService.ts

@@ -1,258 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { EditSchedule } from '../models/EditSchedule';
-import type { NewSchedule } from '../models/NewSchedule';
-import type { Schedule } from '../models/Schedule';
-import type { ScheduleWJobs } from '../models/ScheduleWJobs';
-
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-
-export class ScheduleService {
-
-    /**
-     * preview schedule
-     * @returns string List of 5 estimated upcoming execution events (in UTC)
-     * @throws ApiError
-     */
-    public static previewSchedule({
-        requestBody,
-    }: {
-        /**
-         * schedule
-         */
-        requestBody: {
-            schedule: string;
-            timezone: string;
-        },
-    }): CancelablePromise<Array<string>> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/schedules/preview',
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * create schedule
-     * @returns string schedule created
-     * @throws ApiError
-     */
-    public static createSchedule({
-        workspace,
-        requestBody,
-    }: {
-        workspace: string,
-        /**
-         * new schedule
-         */
-        requestBody: NewSchedule,
-    }): CancelablePromise<string> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/w/{workspace}/schedules/create',
-            path: {
-                'workspace': workspace,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * update schedule
-     * @returns string schedule updated
-     * @throws ApiError
-     */
-    public static updateSchedule({
-        workspace,
-        path,
-        requestBody,
-    }: {
-        workspace: string,
-        path: string,
-        /**
-         * updated schedule
-         */
-        requestBody: EditSchedule,
-    }): CancelablePromise<string> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/w/{workspace}/schedules/update/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * set enabled schedule
-     * @returns string schedule enabled set
-     * @throws ApiError
-     */
-    public static setScheduleEnabled({
-        workspace,
-        path,
-        requestBody,
-    }: {
-        workspace: string,
-        path: string,
-        /**
-         * updated schedule enable
-         */
-        requestBody: {
-            enabled: boolean;
-        },
-    }): CancelablePromise<string> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/w/{workspace}/schedules/setenabled/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-
-    /**
-     * delete schedule
-     * @returns string schedule deleted
-     * @throws ApiError
-     */
-    public static deleteSchedule({
-        workspace,
-        path,
-    }: {
-        workspace: string,
-        path: string,
-    }): CancelablePromise<string> {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/w/{workspace}/schedules/delete/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-        });
-    }
-
-    /**
-     * get schedule
-     * @returns Schedule schedule deleted
-     * @throws ApiError
-     */
-    public static getSchedule({
-        workspace,
-        path,
-    }: {
-        workspace: string,
-        path: string,
-    }): CancelablePromise<Schedule> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/w/{workspace}/schedules/get/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-        });
-    }
-
-    /**
-     * does schedule exists
-     * @returns boolean schedule exists
-     * @throws ApiError
-     */
-    public static existsSchedule({
-        workspace,
-        path,
-    }: {
-        workspace: string,
-        path: string,
-    }): CancelablePromise<boolean> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/w/{workspace}/schedules/exists/{path}',
-            path: {
-                'workspace': workspace,
-                'path': path,
-            },
-        });
-    }
-
-    /**
-     * list schedules
-     * @returns Schedule schedule list
-     * @throws ApiError
-     */
-    public static listSchedules({
-        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<Schedule>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/w/{workspace}/schedules/list',
-            path: {
-                'workspace': workspace,
-            },
-            query: {
-                'page': page,
-                'per_page': perPage,
-            },
-        });
-    }
-
-    /**
-     * list schedules with last 20 jobs
-     * @returns ScheduleWJobs schedule list
-     * @throws ApiError
-     */
-    public static listSchedulesWithJobs({
-        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<ScheduleWJobs>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/w/{workspace}/schedules/list_with_jobs',
-            path: {
-                'workspace': workspace,
-            },
-            query: {
-                'page': page,
-                'per_page': perPage,
-            },
-        });
-    }
-
-}