windmill-client 0.1.0

package/src/services/OauthService.ts

@@ -0,0 +1,197 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { TokenResponse } from '../models/TokenResponse';
+
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+
+export class OauthService {
+
+    /**
+     * connect slack callback
+     * @returns string slack token
+     * @throws ApiError
+     */
+    public static connectSlackCallback({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        /**
+         * code endpoint
+         */
+        requestBody: {
+            code: string;
+            state: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/oauth/connect_slack_callback',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * connect callback
+     * @returns TokenResponse oauth token
+     * @throws ApiError
+     */
+    public static connectCallback({
+        clientName,
+        requestBody,
+    }: {
+        clientName: string,
+        /**
+         * code endpoint
+         */
+        requestBody: {
+            code: string;
+            state: string;
+        },
+    }): CancelablePromise<TokenResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/oauth/connect_callback/{client_name}',
+            path: {
+                'client_name': clientName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * create OAuth account
+     * @returns string account set
+     * @throws ApiError
+     */
+    public static createAccount({
+        workspace,
+        requestBody,
+    }: {
+        workspace: string,
+        /**
+         * code endpoint
+         */
+        requestBody: {
+            refresh_token?: string;
+            expires_in: number;
+            owner: string;
+            client: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/oauth/create_account',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * refresh token
+     * @returns string token refreshed
+     * @throws ApiError
+     */
+    public static refreshToken({
+        workspace,
+        id,
+        requestBody,
+    }: {
+        workspace: string,
+        id: number,
+        /**
+         * variable path
+         */
+        requestBody: {
+            path: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/oauth/refresh_token/{id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * disconnect account
+     * @returns string disconnected client
+     * @throws ApiError
+     */
+    public static disconnectAccount({
+        workspace,
+        id,
+    }: {
+        workspace: string,
+        id: number,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/oauth/disconnect/{id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+            },
+        });
+    }
+
+    /**
+     * disconnect slack
+     * @returns string disconnected slack
+     * @throws ApiError
+     */
+    public static disconnectSlack({
+        workspace,
+    }: {
+        workspace: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/oauth/disconnect_slack',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+
+    /**
+     * list oauth logins
+     * @returns string list of oauth login clients
+     * @throws ApiError
+     */
+    public static listOAuthLogins(): CancelablePromise<Array<string>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/oauth/list_logins',
+        });
+    }
+
+    /**
+     * list oauth connects
+     * @returns any list of oauth connects clients
+     * @throws ApiError
+     */
+    public static listOAuthConnects(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/oauth/list_connects',
+        });
+    }
+
+}

package/src/services/ResourceService.ts

@@ -0,0 +1,395 @@
+/* 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,
+    }: {
+        workspace: string,
+        /**
+         * new resource
+         */
+        requestBody: CreateResource,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/resources/create',
+            path: {
+                'workspace': workspace,
+            },
+            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,
+            },
+        });
+    }
+
+}