windmill-client 1.145.2 → 1.146.0

package/dist/client.d.ts

@@ -0,0 +1,77 @@
+export { AdminService, AuditService, FlowService, GranularAclService, GroupService, JobService, ResourceService, VariableService, ScriptService, ScheduleService, SettingsService, UserService, WorkspaceService, } from "./index";
+export type Sql = string;
+export type Email = string;
+export type Base64 = string;
+export type Resource<S extends string> = any;
+export declare const SHARED_FOLDER = "/shared";
+export declare function setClient(token?: string, baseUrl?: string): void;
+/**
+ * Create a client configuration from env variables
+ * @returns client configuration
+ */
+export declare function getWorkspace(): string;
+/**
+ * Get a resource value by path
+ * @param path path of the resource,  default to internal state path
+ * @param undefinedIfEmpty if the resource does not exist, return undefined instead of throwing an error
+ * @returns resource value
+ */
+export declare function getResource(path?: string, undefinedIfEmpty?: boolean): Promise<any>;
+/**
+ * Resolve a resource value in case the default value was picked because the input payload was undefined
+ * @param obj resource value or path of the resource under the format `$res:path`
+ * @returns resource value
+ */
+export declare function resolveDefaultResource(obj: any): Promise<any>;
+/**
+ * Get the full resource value by path
+ * @param path path of the resource,  default to internal state path
+ * @param undefinedIfEmpty if the resource does not exist, return undefined instead of throwing an error
+ * @returns full resource
+ */
+export declare function getFullResource(path?: string, undefinedIfEmpty?: boolean): Promise<any>;
+export declare function getStatePath(): string;
+/**
+ * Set a resource value by path
+ * @param path path of the resource to set, default to state path
+ * @param value new value of the resource to set
+ * @param initializeToTypeIfNotExist if the resource does not exist, initialize it with this type
+ */
+export declare function setResource(value: any, path?: string, initializeToTypeIfNotExist?: string): Promise<void>;
+/**
+ * Set the state
+ * @param state state to set
+ * @deprecated use setState instead
+ */
+export declare function setInternalState(state: any): Promise<void>;
+/**
+ * Set the state
+ * @param state state to set
+ */
+export declare function setState(state: any): Promise<void>;
+/**
+ * Get the internal state
+ * @deprecated use getState instead
+ */
+export declare function getInternalState(): Promise<any>;
+/**
+ * Get the state shared across executions
+ */
+export declare function getState(): Promise<any>;
+/**
+ * Get a variable by path
+ * @param path path of the variable
+ * @returns variable value
+ */
+export declare function getVariable(path: string): Promise<string | undefined>;
+/**
+ * Set a variable by path, create if not exist
+ * @param path path of the variable
+ * @param value value of the variable
+ * @param isSecretIfNotExist if the variable does not exist, create it as secret or not (default: false)
+ * @param descriptionIfNotExist if the variable does not exist, create it with this description (default: "")
+ */
+export declare function setVariable(path: string, value: string, isSecretIfNotExist?: boolean, descriptionIfNotExist?: string): Promise<void>;
+export declare function databaseUrlFromResource(path: string): Promise<string>;
+export declare function base64ToUint8Array(data: string): Uint8Array;
+export declare function uint8ArrayToBase64(arrayBuffer: Uint8Array): string;

package/dist/client.js

@@ -0,0 +1,368 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uint8ArrayToBase64 = exports.base64ToUint8Array = exports.databaseUrlFromResource = exports.setVariable = exports.getVariable = exports.getState = exports.getInternalState = exports.setState = exports.setInternalState = exports.setResource = exports.getStatePath = exports.getFullResource = exports.resolveDefaultResource = exports.getResource = exports.getWorkspace = exports.setClient = exports.SHARED_FOLDER = exports.WorkspaceService = exports.UserService = exports.SettingsService = exports.ScheduleService = exports.ScriptService = exports.VariableService = exports.ResourceService = exports.JobService = exports.GroupService = exports.GranularAclService = exports.FlowService = exports.AuditService = exports.AdminService = void 0;
+const index_1 = require("./index");
+const index_2 = require("./index");
+var index_3 = require("./index");
+Object.defineProperty(exports, "AdminService", { enumerable: true, get: function () { return index_3.AdminService; } });
+Object.defineProperty(exports, "AuditService", { enumerable: true, get: function () { return index_3.AuditService; } });
+Object.defineProperty(exports, "FlowService", { enumerable: true, get: function () { return index_3.FlowService; } });
+Object.defineProperty(exports, "GranularAclService", { enumerable: true, get: function () { return index_3.GranularAclService; } });
+Object.defineProperty(exports, "GroupService", { enumerable: true, get: function () { return index_3.GroupService; } });
+Object.defineProperty(exports, "JobService", { enumerable: true, get: function () { return index_3.JobService; } });
+Object.defineProperty(exports, "ResourceService", { enumerable: true, get: function () { return index_3.ResourceService; } });
+Object.defineProperty(exports, "VariableService", { enumerable: true, get: function () { return index_3.VariableService; } });
+Object.defineProperty(exports, "ScriptService", { enumerable: true, get: function () { return index_3.ScriptService; } });
+Object.defineProperty(exports, "ScheduleService", { enumerable: true, get: function () { return index_3.ScheduleService; } });
+Object.defineProperty(exports, "SettingsService", { enumerable: true, get: function () { return index_3.SettingsService; } });
+Object.defineProperty(exports, "UserService", { enumerable: true, get: function () { return index_3.UserService; } });
+Object.defineProperty(exports, "WorkspaceService", { enumerable: true, get: function () { return index_3.WorkspaceService; } });
+exports.SHARED_FOLDER = "/shared";
+function setClient(token, baseUrl) {
+    var _a, _b, _c;
+    if (baseUrl === undefined) {
+        baseUrl =
+            (_b = (_a = getEnv("BASE_INTERNAL_URL")) !== null && _a !== void 0 ? _a : getEnv("BASE_URL")) !== null && _b !== void 0 ? _b : "http://localhost:8000";
+    }
+    if (token === undefined) {
+        token = (_c = getEnv("WM_TOKEN")) !== null && _c !== void 0 ? _c : "no_token";
+    }
+    index_2.OpenAPI.WITH_CREDENTIALS = true;
+    index_2.OpenAPI.TOKEN = token;
+    index_2.OpenAPI.BASE = baseUrl + "/api";
+}
+exports.setClient = setClient;
+const getEnv = (key) => {
+    if (typeof window === "undefined") {
+        // node
+        return process.env[key];
+    }
+    // browser
+    return window.process.env[key];
+};
+/**
+ * Create a client configuration from env variables
+ * @returns client configuration
+ */
+function getWorkspace() {
+    var _a;
+    return (_a = getEnv("WM_WORKSPACE")) !== null && _a !== void 0 ? _a : "no_workspace";
+}
+exports.getWorkspace = getWorkspace;
+/**
+ * Get a resource value by path
+ * @param path path of the resource,  default to internal state path
+ * @param undefinedIfEmpty if the resource does not exist, return undefined instead of throwing an error
+ * @returns resource value
+ */
+function getResource(path, undefinedIfEmpty) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const workspace = getWorkspace();
+        path = path !== null && path !== void 0 ? path : getStatePath();
+        try {
+            const resource = yield index_1.ResourceService.getResource({ workspace, path });
+            return yield _transformLeaf(resource.value);
+        }
+        catch (e) {
+            if (undefinedIfEmpty && e.status === 404) {
+                return undefined;
+            }
+            else {
+                throw Error(`Resource not found at ${path} or not visible to you`);
+            }
+        }
+    });
+}
+exports.getResource = getResource;
+/**
+ * Resolve a resource value in case the default value was picked because the input payload was undefined
+ * @param obj resource value or path of the resource under the format `$res:path`
+ * @returns resource value
+ */
+function resolveDefaultResource(obj) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof obj === "string" && obj.startsWith("$res:")) {
+            return yield getResource(obj.substring(5), true);
+        }
+        else {
+            return obj;
+        }
+    });
+}
+exports.resolveDefaultResource = resolveDefaultResource;
+/**
+ * Get the full resource value by path
+ * @param path path of the resource,  default to internal state path
+ * @param undefinedIfEmpty if the resource does not exist, return undefined instead of throwing an error
+ * @returns full resource
+ */
+function getFullResource(path, undefinedIfEmpty) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const workspace = getWorkspace();
+        path = path !== null && path !== void 0 ? path : getStatePath();
+        try {
+            const resource = yield index_1.ResourceService.getResource({ workspace, path });
+            const value = yield _transformLeaf(resource.value);
+            return Object.assign(Object.assign({}, resource), { value });
+        }
+        catch (e) {
+            if (undefinedIfEmpty && e.status === 404) {
+                return undefined;
+            }
+            else {
+                throw Error(`Resource not found at ${path} or not visible to you`);
+            }
+        }
+    });
+}
+exports.getFullResource = getFullResource;
+function getStatePath() {
+    const state_path = getEnv("WM_STATE_PATH_NEW");
+    if (state_path === undefined) {
+        throw Error("State path not set");
+    }
+    return state_path;
+}
+exports.getStatePath = getStatePath;
+/**
+ * Set a resource value by path
+ * @param path path of the resource to set, default to state path
+ * @param value new value of the resource to set
+ * @param initializeToTypeIfNotExist if the resource does not exist, initialize it with this type
+ */
+function setResource(value, path, initializeToTypeIfNotExist) {
+    return __awaiter(this, void 0, void 0, function* () {
+        path = path !== null && path !== void 0 ? path : getStatePath();
+        const workspace = getWorkspace();
+        if (yield index_1.ResourceService.existsResource({ workspace, path })) {
+            yield index_1.ResourceService.updateResourceValue({
+                workspace,
+                path,
+                requestBody: { value },
+            });
+        }
+        else if (initializeToTypeIfNotExist) {
+            yield index_1.ResourceService.createResource({
+                workspace,
+                requestBody: { path, value, resource_type: initializeToTypeIfNotExist },
+            });
+        }
+        else {
+            throw Error(`Resource at path ${path} does not exist and no type was provided to initialize it`);
+        }
+    });
+}
+exports.setResource = setResource;
+/**
+ * Set the state
+ * @param state state to set
+ * @deprecated use setState instead
+ */
+function setInternalState(state) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield setResource(state, undefined, "state");
+    });
+}
+exports.setInternalState = setInternalState;
+/**
+ * Set the state
+ * @param state state to set
+ */
+function setState(state) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield setResource(state, undefined, "state");
+    });
+}
+exports.setState = setState;
+// /**
+//  * Set the shared state
+//  * @param state state to set
+//  */
+// export async function setSharedState(
+//   state: any,
+//   path = "state.json"
+// ): Promise<void> {
+//   await Deno.writeTextFile(SHARED_FOLDER + "/" + path, JSON.stringify(state));
+// }
+// /**
+//  * Get the shared state
+//  * @param state state to set
+//  */
+// export async function getSharedState(path = "state.json"): Promise<any> {
+//   return JSON.parse(await Deno.readTextFile(SHARED_FOLDER + "/" + path));
+// }
+/**
+ * Get the internal state
+ * @deprecated use getState instead
+ */
+function getInternalState() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield getResource(getStatePath(), true);
+    });
+}
+exports.getInternalState = getInternalState;
+/**
+ * Get the state shared across executions
+ */
+function getState() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield getResource(getStatePath(), true);
+    });
+}
+exports.getState = getState;
+/**
+ * Get a variable by path
+ * @param path path of the variable
+ * @returns variable value
+ */
+function getVariable(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const workspace = getWorkspace();
+        try {
+            const variable = yield index_1.VariableService.getVariable({ workspace, path });
+            return variable.value;
+        }
+        catch (e) {
+            throw Error(`Variable not found at ${path} or not visible to you`);
+        }
+    });
+}
+exports.getVariable = getVariable;
+/**
+ * Set a variable by path, create if not exist
+ * @param path path of the variable
+ * @param value value of the variable
+ * @param isSecretIfNotExist if the variable does not exist, create it as secret or not (default: false)
+ * @param descriptionIfNotExist if the variable does not exist, create it with this description (default: "")
+ */
+function setVariable(path, value, isSecretIfNotExist, descriptionIfNotExist) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const workspace = getWorkspace();
+        if (yield index_1.VariableService.existsVariable({ workspace, path })) {
+            yield index_1.VariableService.updateVariable({
+                workspace,
+                path,
+                requestBody: { value },
+            });
+        }
+        else {
+            yield index_1.VariableService.createVariable({
+                workspace,
+                requestBody: {
+                    path,
+                    value,
+                    is_secret: isSecretIfNotExist !== null && isSecretIfNotExist !== void 0 ? isSecretIfNotExist : false,
+                    description: descriptionIfNotExist !== null && descriptionIfNotExist !== void 0 ? descriptionIfNotExist : "",
+                },
+            });
+        }
+    });
+}
+exports.setVariable = setVariable;
+function transformLeaves(d) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const k in d) {
+            d[k] = yield _transformLeaf(d[k]);
+        }
+        return d;
+    });
+}
+const VAR_RESOURCE_PREFIX = "$var:";
+const RES_RESOURCE_PREFIX = "$res:";
+function _transformLeaf(v) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof v === "object") {
+            return transformLeaves(v);
+        }
+        else if (typeof v === "string" && v.startsWith(VAR_RESOURCE_PREFIX)) {
+            const varName = v.substring(VAR_RESOURCE_PREFIX.length);
+            return yield getVariable(varName);
+        }
+        else if (typeof v === "string" && v.startsWith(RES_RESOURCE_PREFIX)) {
+            const resName = v.substring(RES_RESOURCE_PREFIX.length);
+            return yield getResource(resName);
+        }
+        else {
+            return v;
+        }
+    });
+}
+function databaseUrlFromResource(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const resource = yield getResource(path);
+        return `postgresql://${resource.user}:${resource.password}@${resource.host}:${resource.port}/${resource.dbname}?sslmode=${resource.sslmode}`;
+    });
+}
+exports.databaseUrlFromResource = databaseUrlFromResource;
+// /**
+//  * Get URLs needed for resuming a flow after this step
+//  * @param approver approver name
+//  * @returns approval page UI URL, resume and cancel API URLs for resumeing the flow
+//  */
+// export async function getResumeUrls(approver?: string): Promise<{
+//   approvalPage: string;
+//   resume: string;
+//   cancel: string;
+// }> {
+//   const nonce = Math.floor(Math.random() * 4294967295);
+//   const workspace = getWorkspace();
+//   return await JobService.getResumeUrls({
+//     workspace,
+//     resumeId: nonce,
+//     approver,
+//     id: process.env.get("WM_JOB_ID") ?? "NO_JOB_ID",
+//   });
+// }
+function base64ToUint8Array(data) {
+    return Uint8Array.from(atob(data), (c) => c.charCodeAt(0));
+}
+exports.base64ToUint8Array = base64ToUint8Array;
+function uint8ArrayToBase64(arrayBuffer) {
+    let base64 = "";
+    const encodings = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    const bytes = new Uint8Array(arrayBuffer);
+    const byteLength = bytes.byteLength;
+    const byteRemainder = byteLength % 3;
+    const mainLength = byteLength - byteRemainder;
+    let a, b, c, d;
+    let chunk;
+    // Main loop deals with bytes in chunks of 3
+    for (let i = 0; i < mainLength; i = i + 3) {
+        // Combine the three bytes into a single integer
+        chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+        // Use bitmasks to extract 6-bit segments from the triplet
+        a = (chunk & 16515072) >> 18; // 16515072 = (2^6 - 1) << 18
+        b = (chunk & 258048) >> 12; // 258048   = (2^6 - 1) << 12
+        c = (chunk & 4032) >> 6; // 4032     = (2^6 - 1) << 6
+        d = chunk & 63; // 63       = 2^6 - 1
+        // Convert the raw binary segments to the appropriate ASCII encoding
+        base64 += encodings[a] + encodings[b] + encodings[c] + encodings[d];
+    }
+    // Deal with the remaining bytes and padding
+    if (byteRemainder == 1) {
+        chunk = bytes[mainLength];
+        a = (chunk & 252) >> 2; // 252 = (2^6 - 1) << 2
+        // Set the 4 least significant bits to zero
+        b = (chunk & 3) << 4; // 3   = 2^2 - 1
+        base64 += encodings[a] + encodings[b] + "==";
+    }
+    else if (byteRemainder == 2) {
+        chunk = (bytes[mainLength] << 8) | bytes[mainLength + 1];
+        a = (chunk & 64512) >> 10; // 64512 = (2^6 - 1) << 10
+        b = (chunk & 1008) >> 4; // 1008  = (2^6 - 1) << 4
+        // Set the 2 least significant bits to zero
+        c = (chunk & 15) << 2; // 15    = 2^4 - 1
+        base64 += encodings[a] + encodings[b] + encodings[c] + "=";
+    }
+    return base64;
+}
+exports.uint8ArrayToBase64 = uint8ArrayToBase64;

package/dist/core/ApiError.d.ts

@@ -0,0 +1,10 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+export declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}

package/dist/core/ApiError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+class ApiError extends Error {
+    constructor(request, response, message) {
+        super(message);
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}
+exports.ApiError = ApiError;

package/dist/core/ApiRequestOptions.d.ts

@@ -0,0 +1,13 @@
+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 body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/dist/core/ApiRequestOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/ApiResult.d.ts

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

package/dist/core/ApiResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/CancelablePromise.d.ts

@@ -0,0 +1,20 @@
+export declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+export interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (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);
+    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>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}

package/dist/core/CancelablePromise.js

@@ -0,0 +1,116 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CancelablePromise_isResolved, _CancelablePromise_isRejected, _CancelablePromise_isCancelled, _CancelablePromise_cancelHandlers, _CancelablePromise_promise, _CancelablePromise_resolve, _CancelablePromise_reject;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelablePromise = exports.CancelError = void 0;
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+class CancelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CancelError';
+    }
+    get isCancelled() {
+        return true;
+    }
+}
+exports.CancelError = CancelError;
+class CancelablePromise {
+    constructor(executor) {
+        _CancelablePromise_isResolved.set(this, void 0);
+        _CancelablePromise_isRejected.set(this, void 0);
+        _CancelablePromise_isCancelled.set(this, void 0);
+        _CancelablePromise_cancelHandlers.set(this, void 0);
+        _CancelablePromise_promise.set(this, void 0);
+        _CancelablePromise_resolve.set(this, void 0);
+        _CancelablePromise_reject.set(this, void 0);
+        __classPrivateFieldSet(this, _CancelablePromise_isResolved, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_isRejected, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_isCancelled, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_cancelHandlers, [], "f");
+        __classPrivateFieldSet(this, _CancelablePromise_promise, new Promise((resolve, reject) => {
+            __classPrivateFieldSet(this, _CancelablePromise_resolve, resolve, "f");
+            __classPrivateFieldSet(this, _CancelablePromise_reject, reject, "f");
+            const onResolve = (value) => {
+                var _a;
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isResolved, true, "f");
+                (_a = __classPrivateFieldGet(this, _CancelablePromise_resolve, "f")) === null || _a === void 0 ? void 0 : _a.call(this, value);
+            };
+            const onReject = (reason) => {
+                var _a;
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isRejected, true, "f");
+                (_a = __classPrivateFieldGet(this, _CancelablePromise_reject, "f")) === null || _a === void 0 ? void 0 : _a.call(this, reason);
+            };
+            const onCancel = (cancelHandler) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").push(cancelHandler);
+            };
+            Object.defineProperty(onCancel, 'isResolved', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isResolved, "f"),
+            });
+            Object.defineProperty(onCancel, 'isRejected', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f"),
+            });
+            Object.defineProperty(onCancel, 'isCancelled', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f"),
+            });
+            return executor(onResolve, onReject, onCancel);
+        }), "f");
+    }
+    get [(_CancelablePromise_isResolved = new WeakMap(), _CancelablePromise_isRejected = new WeakMap(), _CancelablePromise_isCancelled = new WeakMap(), _CancelablePromise_cancelHandlers = new WeakMap(), _CancelablePromise_promise = new WeakMap(), _CancelablePromise_resolve = new WeakMap(), _CancelablePromise_reject = new WeakMap(), Symbol.toStringTag)]() {
+        return "Cancellable Promise";
+    }
+    then(onFulfilled, onRejected) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").catch(onRejected);
+    }
+    finally(onFinally) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").finally(onFinally);
+    }
+    cancel() {
+        var _a;
+        if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+            return;
+        }
+        __classPrivateFieldSet(this, _CancelablePromise_isCancelled, true, "f");
+        if (__classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length) {
+            try {
+                for (const cancelHandler of __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f")) {
+                    cancelHandler();
+                }
+            }
+            catch (error) {
+                console.warn('Cancellation threw an error', error);
+                return;
+            }
+        }
+        __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length = 0;
+        (_a = __classPrivateFieldGet(this, _CancelablePromise_reject, "f")) === null || _a === void 0 ? void 0 : _a.call(this, new CancelError('Request aborted'));
+    }
+    get isCancelled() {
+        return __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f");
+    }
+}
+exports.CancelablePromise = CancelablePromise;

package/dist/core/OpenAPI.d.ts

@@ -0,0 +1,16 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+export type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    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;
+};
+export declare const OpenAPI: OpenAPIConfig;
+export {};

package/dist/core/OpenAPI.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPI = void 0;
+exports.OpenAPI = {
+    BASE: '/api',
+    VERSION: '1.146.0',
+    WITH_CREDENTIALS: false,
+    CREDENTIALS: 'include',
+    TOKEN: undefined,
+    USERNAME: undefined,
+    PASSWORD: undefined,
+    HEADERS: undefined,
+    ENCODE_PATH: undefined,
+};