windmill-components 1.306.13 → 1.309.2

package/package/gen/core/ApiRequestOptions.d.ts

@@ -1,11 +1,11 @@
 export type ApiRequestOptions = {
     readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
     readonly url: string;
-    readonly path?: Record<string, any>;
-    readonly cookies?: Record<string, any>;
-    readonly headers?: Record<string, any>;
-    readonly query?: Record<string, any>;
-    readonly formData?: Record<string, any>;
+    readonly path?: Record<string, unknown>;
+    readonly cookies?: Record<string, unknown>;
+    readonly headers?: Record<string, unknown>;
+    readonly query?: Record<string, unknown>;
+    readonly formData?: Record<string, unknown>;
     readonly body?: any;
     readonly mediaType?: string;
     readonly responseHeader?: string;

package/package/gen/core/ApiResult.d.ts

@@ -1,7 +1,7 @@
-export type ApiResult = {
-    readonly url: string;
+export type ApiResult<TData = any> = {
+    readonly body: TData;
     readonly ok: boolean;
     readonly status: number;
     readonly statusText: string;
-    readonly body: any;
+    readonly url: string;
 };

package/package/gen/core/CancelablePromise.d.ts

@@ -9,11 +9,17 @@ export interface OnCancel {
     (cancelHandler: () => void): void;
 }
 export declare class CancelablePromise<T> implements Promise<T> {
-    #private;
-    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    private _isResolved;
+    private _isRejected;
+    private _isCancelled;
+    readonly cancelHandlers: (() => void)[];
+    readonly promise: Promise<T>;
+    private _resolve?;
+    private _reject?;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: unknown) => void, onCancel: OnCancel) => void);
     get [Symbol.toStringTag](): string;
-    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
     finally(onFinally?: (() => void) | null): Promise<T>;
     cancel(): void;
     get isCancelled(): boolean;

package/package/gen/core/CancelablePromise.js

@@ -1,7 +1,3 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 export class CancelError extends Error {
     constructor(message) {
         super(message);
@@ -12,49 +8,51 @@ export class CancelError extends Error {
     }
 }
 export class CancelablePromise {
-    #isResolved;
-    #isRejected;
-    #isCancelled;
-    #cancelHandlers;
-    #promise;
-    #resolve;
-    #reject;
+    _isResolved;
+    _isRejected;
+    _isCancelled;
+    cancelHandlers;
+    promise;
+    _resolve;
+    _reject;
     constructor(executor) {
-        this.#isResolved = false;
-        this.#isRejected = false;
-        this.#isCancelled = false;
-        this.#cancelHandlers = [];
-        this.#promise = new Promise((resolve, reject) => {
-            this.#resolve = resolve;
-            this.#reject = reject;
+        this._isResolved = false;
+        this._isRejected = false;
+        this._isCancelled = false;
+        this.cancelHandlers = [];
+        this.promise = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
             const onResolve = (value) => {
-                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+                if (this._isResolved || this._isRejected || this._isCancelled) {
                     return;
                 }
-                this.#isResolved = true;
-                this.#resolve?.(value);
+                this._isResolved = true;
+                if (this._resolve)
+                    this._resolve(value);
             };
             const onReject = (reason) => {
-                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+                if (this._isResolved || this._isRejected || this._isCancelled) {
                     return;
                 }
-                this.#isRejected = true;
-                this.#reject?.(reason);
+                this._isRejected = true;
+                if (this._reject)
+                    this._reject(reason);
             };
             const onCancel = (cancelHandler) => {
-                if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+                if (this._isResolved || this._isRejected || this._isCancelled) {
                     return;
                 }
-                this.#cancelHandlers.push(cancelHandler);
+                this.cancelHandlers.push(cancelHandler);
             };
             Object.defineProperty(onCancel, 'isResolved', {
-                get: () => this.#isResolved,
+                get: () => this._isResolved,
             });
             Object.defineProperty(onCancel, 'isRejected', {
-                get: () => this.#isRejected,
+                get: () => this._isRejected,
             });
             Object.defineProperty(onCancel, 'isCancelled', {
-                get: () => this.#isCancelled,
+                get: () => this._isCancelled,
             });
             return executor(onResolve, onReject, onCancel);
         });
@@ -63,22 +61,22 @@ export class CancelablePromise {
         return "Cancellable Promise";
     }
     then(onFulfilled, onRejected) {
-        return this.#promise.then(onFulfilled, onRejected);
+        return this.promise.then(onFulfilled, onRejected);
     }
     catch(onRejected) {
-        return this.#promise.catch(onRejected);
+        return this.promise.catch(onRejected);
     }
     finally(onFinally) {
-        return this.#promise.finally(onFinally);
+        return this.promise.finally(onFinally);
     }
     cancel() {
-        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
             return;
         }
-        this.#isCancelled = true;
-        if (this.#cancelHandlers.length) {
+        this._isCancelled = true;
+        if (this.cancelHandlers.length) {
             try {
-                for (const cancelHandler of this.#cancelHandlers) {
+                for (const cancelHandler of this.cancelHandlers) {
                     cancelHandler();
                 }
             }
@@ -87,10 +85,11 @@ export class CancelablePromise {
                 return;
             }
         }
-        this.#cancelHandlers.length = 0;
-        this.#reject?.(new CancelError('Request aborted'));
+        this.cancelHandlers.length = 0;
+        if (this._reject)
+            this._reject(new CancelError('Request aborted'));
     }
     get isCancelled() {
-        return this.#isCancelled;
+        return this._isCancelled;
     }
 }

package/package/gen/core/OpenAPI.d.ts

@@ -1,16 +1,27 @@
 import type { ApiRequestOptions } from './ApiRequestOptions';
-type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
 type Headers = Record<string, string>;
+type Middleware<T> = (value: T) => T | Promise<T>;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+export declare class Interceptors<T> {
+    _fns: Middleware<T>[];
+    constructor();
+    eject(fn: Middleware<T>): void;
+    use(fn: Middleware<T>): void;
+}
 export type OpenAPIConfig = {
     BASE: string;
-    VERSION: string;
-    WITH_CREDENTIALS: boolean;
     CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
     TOKEN?: string | Resolver<string> | undefined;
     USERNAME?: string | Resolver<string> | undefined;
-    PASSWORD?: string | Resolver<string> | undefined;
-    HEADERS?: Headers | Resolver<Headers> | undefined;
-    ENCODE_PATH?: ((path: string) => string) | undefined;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    interceptors: {
+        request: Interceptors<RequestInit>;
+        response: Interceptors<Response>;
+    };
 };
 export declare const OpenAPI: OpenAPIConfig;
 export {};

package/package/gen/core/OpenAPI.js

@@ -1,11 +1,31 @@
+export class Interceptors {
+    _fns;
+    constructor() {
+        this._fns = [];
+    }
+    eject(fn) {
+        const index = this._fns.indexOf(fn);
+        if (index !== -1) {
+            this._fns = [
+                ...this._fns.slice(0, index),
+                ...this._fns.slice(index + 1),
+            ];
+        }
+    }
+    use(fn) {
+        this._fns = [...this._fns, fn];
+    }
+}
 export const OpenAPI = {
     BASE: '/api',
-    VERSION: '1.304.3',
-    WITH_CREDENTIALS: false,
     CREDENTIALS: 'include',
+    ENCODE_PATH: undefined,
+    HEADERS: undefined,
+    PASSWORD: undefined,
     TOKEN: undefined,
     USERNAME: undefined,
-    PASSWORD: undefined,
-    HEADERS: undefined,
-    ENCODE_PATH: undefined,
+    VERSION: '1.309.1',
+    WITH_CREDENTIALS: false,
+    interceptors: { request: new Interceptors(), response: new Interceptors(),
+    },
 };

package/package/gen/core/request.d.ts

@@ -3,21 +3,20 @@ import type { ApiResult } from './ApiResult';
 import { CancelablePromise } from './CancelablePromise';
 import type { OnCancel } from './CancelablePromise';
 import type { OpenAPIConfig } from './OpenAPI';
-export declare const isDefined: <T>(value: T | null | undefined) => value is Exclude<T, null | undefined>;
-export declare const isString: (value: any) => value is string;
-export declare const isStringWithValue: (value: any) => value is string;
+export declare const isString: (value: unknown) => value is string;
+export declare const isStringWithValue: (value: unknown) => value is string;
 export declare const isBlob: (value: any) => value is Blob;
-export declare const isFormData: (value: any) => value is FormData;
+export declare const isFormData: (value: unknown) => value is FormData;
 export declare const base64: (str: string) => string;
-export declare const getQueryString: (params: Record<string, any>) => string;
+export declare const getQueryString: (params: Record<string, unknown>) => string;
 export declare const getFormData: (options: ApiRequestOptions) => FormData | undefined;
 type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
 export declare const resolve: <T>(options: ApiRequestOptions, resolver?: T | Resolver<T> | undefined) => Promise<T | undefined>;
 export declare const getHeaders: (config: OpenAPIConfig, options: ApiRequestOptions) => Promise<Headers>;
-export declare const getRequestBody: (options: ApiRequestOptions) => any;
+export declare const getRequestBody: (options: ApiRequestOptions) => unknown;
 export declare const sendRequest: (config: OpenAPIConfig, options: ApiRequestOptions, url: string, body: any, formData: FormData | undefined, headers: Headers, onCancel: OnCancel) => Promise<Response>;
 export declare const getResponseHeader: (response: Response, responseHeader?: string) => string | undefined;
-export declare const getResponseBody: (response: Response) => Promise<any>;
+export declare const getResponseBody: (response: Response) => Promise<unknown>;
 export declare const catchErrorCodes: (options: ApiRequestOptions, result: ApiResult) => void;
 /**
  * Request method

package/package/gen/core/request.js

@@ -1,12 +1,5 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 import { ApiError } from './ApiError';
 import { CancelablePromise } from './CancelablePromise';
-export const isDefined = (value) => {
-    return value !== undefined && value !== null;
-};
 export const isString = (value) => {
     return typeof value === 'string';
 };
@@ -14,14 +7,7 @@ export const isStringWithValue = (value) => {
     return isString(value) && value !== '';
 };
 export const isBlob = (value) => {
-    return (typeof value === 'object' &&
-        typeof value.type === 'string' &&
-        typeof value.stream === 'function' &&
-        typeof value.arrayBuffer === 'function' &&
-        typeof value.constructor === 'function' &&
-        typeof value.constructor.name === 'string' &&
-        /^(Blob|File)$/.test(value.constructor.name) &&
-        /^(Blob|File)$/.test(value[Symbol.toStringTag]));
+    return value instanceof Blob;
 };
 export const isFormData = (value) => {
     return value instanceof FormData;
@@ -40,30 +26,22 @@ export const getQueryString = (params) => {
     const append = (key, value) => {
         qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
     };
-    const process = (key, value) => {
-        if (isDefined(value)) {
-            if (Array.isArray(value)) {
-                value.forEach(v => {
-                    process(key, v);
-                });
-            }
-            else if (typeof value === 'object') {
-                Object.entries(value).forEach(([k, v]) => {
-                    process(`${key}[${k}]`, v);
-                });
-            }
-            else {
-                append(key, value);
-            }
+    const encodePair = (key, value) => {
+        if (value === undefined || value === null) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            value.forEach(v => encodePair(key, v));
+        }
+        else if (typeof value === 'object') {
+            Object.entries(value).forEach(([k, v]) => encodePair(`${key}[${k}]`, v));
+        }
+        else {
+            append(key, value);
         }
     };
-    Object.entries(params).forEach(([key, value]) => {
-        process(key, value);
-    });
-    if (qs.length > 0) {
-        return `?${qs.join('&')}`;
-    }
-    return '';
+    Object.entries(params).forEach(([key, value]) => encodePair(key, value));
+    return qs.length ? `?${qs.join('&')}` : '';
 };
 const getUrl = (config, options) => {
     const encoder = config.ENCODE_PATH || encodeURI;
@@ -75,11 +53,8 @@ const getUrl = (config, options) => {
         }
         return substring;
     });
-    const url = `${config.BASE}${path}`;
-    if (options.query) {
-        return `${url}${getQueryString(options.query)}`;
-    }
-    return url;
+    const url = config.BASE + path;
+    return options.query ? url + getQueryString(options.query) : url;
 };
 export const getFormData = (options) => {
     if (options.formData) {
@@ -93,7 +68,7 @@ export const getFormData = (options) => {
             }
         };
         Object.entries(options.formData)
-            .filter(([_, value]) => isDefined(value))
+            .filter(([, value]) => value !== undefined && value !== null)
             .forEach(([key, value]) => {
             if (Array.isArray(value)) {
                 value.forEach(v => process(key, v));
@@ -113,16 +88,18 @@ export const resolve = async (options, resolver) => {
     return resolver;
 };
 export const getHeaders = async (config, options) => {
-    const token = await resolve(options, config.TOKEN);
-    const username = await resolve(options, config.USERNAME);
-    const password = await resolve(options, config.PASSWORD);
-    const additionalHeaders = await resolve(options, config.HEADERS);
+    const [token, username, password, additionalHeaders] = await Promise.all([
+        resolve(options, config.TOKEN),
+        resolve(options, config.USERNAME),
+        resolve(options, config.PASSWORD),
+        resolve(options, config.HEADERS),
+    ]);
     const headers = Object.entries({
         Accept: 'application/json',
         ...additionalHeaders,
         ...options.headers,
     })
-        .filter(([_, value]) => isDefined(value))
+        .filter(([, value]) => value !== undefined && value !== null)
         .reduce((headers, [key, value]) => ({
         ...headers,
         [key]: String(value),
@@ -134,7 +111,7 @@ export const getHeaders = async (config, options) => {
         const credentials = base64(`${username}:${password}`);
         headers['Authorization'] = `Basic ${credentials}`;
     }
-    if (options.body) {
+    if (options.body !== undefined) {
         if (options.mediaType) {
             headers['Content-Type'] = options.mediaType;
         }
@@ -152,7 +129,7 @@ export const getHeaders = async (config, options) => {
 };
 export const getRequestBody = (options) => {
     if (options.body !== undefined) {
-        if (options.mediaType?.includes('/json')) {
+        if (options.mediaType?.includes('application/json') || options.mediaType?.includes('+json')) {
             return JSON.stringify(options.body);
         }
         else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
@@ -166,7 +143,7 @@ export const getRequestBody = (options) => {
 };
 export const sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
     const controller = new AbortController();
-    const request = {
+    let request = {
         headers,
         body: body ?? formData,
         method: options.method,
@@ -174,7 +151,9 @@ export const sendRequest = async (config, options, url, body, formData, headers,
     };
     if (config.WITH_CREDENTIALS) {
         request.credentials = config.CREDENTIALS;
-        request.referrerPolicy = "no-referrer";
+    }
+    for (const fn of config.interceptors.request._fns) {
+        request = await fn(request);
     }
     onCancel(() => controller.abort());
     return await fetch(url, request);
@@ -193,12 +172,17 @@ export const getResponseBody = async (response) => {
         try {
             const contentType = response.headers.get('Content-Type');
             if (contentType) {
-                const jsonTypes = ['application/json', 'application/problem+json'];
-                const isJSON = jsonTypes.some(type => contentType.toLowerCase().startsWith(type));
-                if (isJSON) {
+                const binaryTypes = ['application/octet-stream', 'application/pdf', 'application/zip', 'audio/', 'image/', 'video/'];
+                if (contentType.includes('application/json') || contentType.includes('+json')) {
                     return await response.json();
                 }
-                else {
+                else if (binaryTypes.some(type => contentType.includes(type))) {
+                    return await response.blob();
+                }
+                else if (contentType.includes('multipart/form-data')) {
+                    return await response.formData();
+                }
+                else if (contentType.includes('text/')) {
                     return await response.text();
                 }
             }
@@ -213,11 +197,44 @@ export const catchErrorCodes = (options, result) => {
     const errors = {
         400: 'Bad Request',
         401: 'Unauthorized',
+        402: 'Payment Required',
         403: 'Forbidden',
         404: 'Not Found',
+        405: 'Method Not Allowed',
+        406: 'Not Acceptable',
+        407: 'Proxy Authentication Required',
+        408: 'Request Timeout',
+        409: 'Conflict',
+        410: 'Gone',
+        411: 'Length Required',
+        412: 'Precondition Failed',
+        413: 'Payload Too Large',
+        414: 'URI Too Long',
+        415: 'Unsupported Media Type',
+        416: 'Range Not Satisfiable',
+        417: 'Expectation Failed',
+        418: 'Im a teapot',
+        421: 'Misdirected Request',
+        422: 'Unprocessable Content',
+        423: 'Locked',
+        424: 'Failed Dependency',
+        425: 'Too Early',
+        426: 'Upgrade Required',
+        428: 'Precondition Required',
+        429: 'Too Many Requests',
+        431: 'Request Header Fields Too Large',
+        451: 'Unavailable For Legal Reasons',
         500: 'Internal Server Error',
+        501: 'Not Implemented',
         502: 'Bad Gateway',
         503: 'Service Unavailable',
+        504: 'Gateway Timeout',
+        505: 'HTTP Version Not Supported',
+        506: 'Variant Also Negotiates',
+        507: 'Insufficient Storage',
+        508: 'Loop Detected',
+        510: 'Not Extended',
+        511: 'Network Authentication Required',
         ...options.errors,
     };
     const error = errors[result.status];
@@ -253,7 +270,10 @@ export const request = (config, options) => {
             const body = getRequestBody(options);
             const headers = await getHeaders(config, options);
             if (!onCancel.isCancelled) {
-                const response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+                let response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+                for (const fn of config.interceptors.response._fns) {
+                    response = await fn(response);
+                }
                 const responseBody = await getResponseBody(response);
                 const responseHeader = getResponseHeader(response, options.responseHeader);
                 const result = {

package/package/gen/enums.gen.d.ts

@@ -0,0 +1,149 @@
+export declare const LanguageEnum: {
+    readonly PYTHON3: "python3";
+    readonly DENO: "deno";
+    readonly GO: "go";
+    readonly BASH: "bash";
+    readonly POWERSHELL: "powershell";
+    readonly POSTGRESQL: "postgresql";
+    readonly MYSQL: "mysql";
+    readonly BIGQUERY: "bigquery";
+    readonly SNOWFLAKE: "snowflake";
+    readonly MSSQL: "mssql";
+    readonly GRAPHQL: "graphql";
+    readonly NATIVETS: "nativets";
+    readonly BUN: "bun";
+};
+export declare const KindEnum: {
+    readonly SCRIPT: "script";
+    readonly FAILURE: "failure";
+    readonly TRIGGER: "trigger";
+    readonly COMMAND: "command";
+    readonly APPROVAL: "approval";
+};
+export declare const RunnableTypeEnum: {
+    readonly SCRIPT_HASH: "ScriptHash";
+    readonly SCRIPT_PATH: "ScriptPath";
+    readonly FLOW_PATH: "FlowPath";
+};
+export declare const JobKindEnum: {
+    readonly SCRIPT: "script";
+    readonly PREVIEW: "preview";
+    readonly DEPENDENCIES: "dependencies";
+    readonly FLOWDEPENDENCIES: "flowdependencies";
+    readonly APPDEPENDENCIES: "appdependencies";
+    readonly FLOW: "flow";
+    readonly FLOWPREVIEW: "flowpreview";
+    readonly SCRIPT_HUB: "script_hub";
+    readonly IDENTITY: "identity";
+    readonly DEPLOYMENTCALLBACK: "deploymentcallback";
+    readonly SINGLESCRIPTFLOW: "singlescriptflow";
+};
+export declare const TypeEnum: {
+    readonly COMPLETED_JOB: "CompletedJob";
+};
+export declare const OperationEnum: {
+    readonly JOBS_RUN: "jobs.run";
+    readonly JOBS_RUN_SCRIPT: "jobs.run.script";
+    readonly JOBS_RUN_PREVIEW: "jobs.run.preview";
+    readonly JOBS_RUN_FLOW: "jobs.run.flow";
+    readonly JOBS_RUN_FLOW_PREVIEW: "jobs.run.flow_preview";
+    readonly JOBS_RUN_SCRIPT_HUB: "jobs.run.script_hub";
+    readonly JOBS_RUN_DEPENDENCIES: "jobs.run.dependencies";
+    readonly JOBS_RUN_IDENTITY: "jobs.run.identity";
+    readonly JOBS_RUN_NOOP: "jobs.run.noop";
+    readonly JOBS_FLOW_DEPENDENCIES: "jobs.flow_dependencies";
+    readonly JOBS: "jobs";
+    readonly JOBS_CANCEL: "jobs.cancel";
+    readonly JOBS_FORCE_CANCEL: "jobs.force_cancel";
+    readonly JOBS_DISAPPROVAL: "jobs.disapproval";
+    readonly JOBS_DELETE: "jobs.delete";
+    readonly ACCOUNT_DELETE: "account.delete";
+    readonly OPENAI_REQUEST: "openai.request";
+    readonly RESOURCES_CREATE: "resources.create";
+    readonly RESOURCES_UPDATE: "resources.update";
+    readonly RESOURCES_DELETE: "resources.delete";
+    readonly RESOURCE_TYPES_CREATE: "resource_types.create";
+    readonly RESOURCE_TYPES_UPDATE: "resource_types.update";
+    readonly RESOURCE_TYPES_DELETE: "resource_types.delete";
+    readonly SCHEDULE_CREATE: "schedule.create";
+    readonly SCHEDULE_SETENABLED: "schedule.setenabled";
+    readonly SCHEDULE_EDIT: "schedule.edit";
+    readonly SCHEDULE_DELETE: "schedule.delete";
+    readonly SCRIPTS_CREATE: "scripts.create";
+    readonly SCRIPTS_UPDATE: "scripts.update";
+    readonly SCRIPTS_ARCHIVE: "scripts.archive";
+    readonly SCRIPTS_DELETE: "scripts.delete";
+    readonly USERS_CREATE: "users.create";
+    readonly USERS_DELETE: "users.delete";
+    readonly USERS_UPDATE: "users.update";
+    readonly USERS_LOGIN: "users.login";
+    readonly USERS_LOGOUT: "users.logout";
+    readonly USERS_ACCEPT_INVITE: "users.accept_invite";
+    readonly USERS_DECLINE_INVITE: "users.decline_invite";
+    readonly USERS_TOKEN_CREATE: "users.token.create";
+    readonly USERS_TOKEN_DELETE: "users.token.delete";
+    readonly USERS_ADD_TO_WORKSPACE: "users.add_to_workspace";
+    readonly USERS_ADD_GLOBAL: "users.add_global";
+    readonly USERS_SETPASSWORD: "users.setpassword";
+    readonly USERS_IMPERSONATE: "users.impersonate";
+    readonly USERS_LEAVE_WORKSPACE: "users.leave_workspace";
+    readonly OAUTH_LOGIN: "oauth.login";
+    readonly OAUTH_SIGNUP: "oauth.signup";
+    readonly VARIABLES_CREATE: "variables.create";
+    readonly VARIABLES_DELETE: "variables.delete";
+    readonly VARIABLES_UPDATE: "variables.update";
+    readonly FLOWS_CREATE: "flows.create";
+    readonly FLOWS_UPDATE: "flows.update";
+    readonly FLOWS_DELETE: "flows.delete";
+    readonly FLOWS_ARCHIVE: "flows.archive";
+    readonly APPS_CREATE: "apps.create";
+    readonly APPS_UPDATE: "apps.update";
+    readonly APPS_DELETE: "apps.delete";
+    readonly FOLDER_CREATE: "folder.create";
+    readonly FOLDER_UPDATE: "folder.update";
+    readonly FOLDER_DELETE: "folder.delete";
+    readonly FOLDER_ADD_OWNER: "folder.add_owner";
+    readonly FOLDER_REMOVE_OWNER: "folder.remove_owner";
+    readonly GROUP_CREATE: "group.create";
+    readonly GROUP_DELETE: "group.delete";
+    readonly GROUP_EDIT: "group.edit";
+    readonly GROUP_ADDUSER: "group.adduser";
+    readonly GROUP_REMOVEUSER: "group.removeuser";
+    readonly IGROUP_CREATE: "igroup.create";
+    readonly IGROUP_DELETE: "igroup.delete";
+    readonly IGROUP_ADDUSER: "igroup.adduser";
+    readonly IGROUP_REMOVEUSER: "igroup.removeuser";
+    readonly VARIABLES_DECRYPT_SECRET: "variables.decrypt_secret";
+    readonly WORKSPACES_EDIT_COMMAND_SCRIPT: "workspaces.edit_command_script";
+    readonly WORKSPACES_EDIT_DEPLOY_TO: "workspaces.edit_deploy_to";
+    readonly WORKSPACES_EDIT_AUTO_INVITE_DOMAIN: "workspaces.edit_auto_invite_domain";
+    readonly WORKSPACES_EDIT_WEBHOOK: "workspaces.edit_webhook";
+    readonly WORKSPACES_EDIT_COPILOT_CONFIG: "workspaces.edit_copilot_config";
+    readonly WORKSPACES_EDIT_ERROR_HANDLER: "workspaces.edit_error_handler";
+    readonly WORKSPACES_CREATE: "workspaces.create";
+    readonly WORKSPACES_UPDATE: "workspaces.update";
+    readonly WORKSPACES_ARCHIVE: "workspaces.archive";
+    readonly WORKSPACES_UNARCHIVE: "workspaces.unarchive";
+    readonly WORKSPACES_DELETE: "workspaces.delete";
+};
+export declare const ActionKindEnum: {
+    readonly CREATED: "Created";
+    readonly UPDATED: "Updated";
+    readonly DELETE: "Delete";
+    readonly EXECUTE: "Execute";
+};
+export declare const LoginTypeEnum: {
+    readonly PASSWORD: "password";
+    readonly GITHUB: "github";
+};
+export declare const ExecutionModeEnum: {
+    readonly VIEWER: "viewer";
+    readonly PUBLISHER: "publisher";
+    readonly ANONYMOUS: "anonymous";
+};
+export declare const ContentTypeEnum: {
+    readonly RAW_TEXT: "RawText";
+    readonly CSV: "Csv";
+    readonly PARQUET: "Parquet";
+    readonly UNKNOWN: "Unknown";
+};