@civitai/client 0.1.1-beta.0

package/dist/client/CivitaiClient.d.ts

@@ -0,0 +1,17 @@
+import { BaseHttpRequest } from '../generated/core/BaseHttpRequest';
+import { Interceptors, OpenAPIConfig } from '../generated/core/OpenAPI';
+import { GeneratedClient } from '../generated/GeneratedClient';
+type ClientConfig = {
+  env?: 'dev' | 'prod';
+  base?: string;
+  auth: string;
+  interceptors?: {
+    request?: Interceptors<RequestInit>;
+    response?: Interceptors<Response>;
+  };
+};
+type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
+export declare class CivitaiClient extends GeneratedClient {
+  constructor(config: ClientConfig, HttpRequest?: HttpRequestConstructor);
+}
+export {};

package/dist/client/CivitaiClient.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CivitaiClient = void 0;
+const OpenAPI_1 = require("../generated/core/OpenAPI");
+const GeneratedClient_1 = require("../generated/GeneratedClient");
+class CivitaiClient extends GeneratedClient_1.GeneratedClient {
+    constructor(config, HttpRequest) {
+        var _a, _b, _c, _d;
+        super({
+            BASE: config.env === 'dev'
+                ? 'https://orchestration-dev.civitai.com'
+                : 'https://orchestration-stage.civitai.com', // TODO: Switch to orchestration.civitai.com once prod is back up and running
+            HEADERS: { Authorization: `Bearer ${config.auth}` },
+            interceptors: {
+                request: (_b = (_a = config === null || config === void 0 ? void 0 : config.interceptors) === null || _a === void 0 ? void 0 : _a.request) !== null && _b !== void 0 ? _b : new OpenAPI_1.Interceptors(),
+                response: (_d = (_c = config === null || config === void 0 ? void 0 : config.interceptors) === null || _c === void 0 ? void 0 : _c.response) !== null && _d !== void 0 ? _d : new OpenAPI_1.Interceptors(),
+            },
+        }, HttpRequest);
+    }
+}
+exports.CivitaiClient = CivitaiClient;
+// const test = new CivitaiClient({ auth: '' });
+// test.requests.submitRequest([{ $type: 'textToImage' }]);
+// test.workflows.submitRequest({requestBody: {} as TextToImageStep})

package/dist/client/RequestsClient.js

@@ -0,0 +1,58 @@
+"use strict";
+// import {
+//   BaseHttpRequest,
+//   CancelError,
+//   CancelablePromise,
+//   JobTemplateReference,
+//   RequestInfo,
+//   RequestsService,
+//   ResultInclusion,
+// } from '../generated';
+// export class RequestsClient extends RequestsService {
+//   constructor(public readonly httpRequest: BaseHttpRequest) {
+//     super(httpRequest);
+//   }
+//   public override submitRequest(
+//     props?: {
+//       include?: ResultInclusion | undefined;
+//       requestBody?: JobTemplateReference | JobTemplateReference[] | undefined;
+//       wait?: boolean | undefined;
+//       whatif?: boolean | undefined;
+//     },
+//     options?: { cleanupOnCancellation?: boolean }
+//   ): CancelablePromise<RequestInfo> {
+//     return new CancelablePromise<RequestInfo>(async (resolve, reject, oncancel) => {
+//       try {
+//         const { wait, include } = props ?? {};
+//         const { cleanupOnCancellation = true } = options ?? {};
+//         let result = await withCancellation(super.submitRequest({ ...props, wait: false }));
+//         if (!result) throw new Error('no result');
+//         try {
+//           while (wait && (result.status === 'Initialized' || result.status === 'Processing')) {
+//             result = await withCancellation(
+//               this.getRequest({ requestId: result.id, include, wait })
+//             );
+//           }
+//           resolve(result);
+//         } catch (error) {
+//           if (error instanceof CancelError && wait && cleanupOnCancellation) {
+//             console.log('cancelling request');
+//             await this.updateRequest({
+//               requestId: result.id,
+//               requestBody: {
+//                 status: 'Canceled',
+//               },
+//             });
+//           }
+//           throw error;
+//         }
+//       } catch (error) {
+//         reject(error);
+//       }
+//       function withCancellation<T>(promise: CancelablePromise<T>) {
+//         oncancel(promise.cancel);
+//         return promise;
+//       }
+//     });
+//   }
+// }

package/dist/generated/GeneratedClient.d.ts

@@ -0,0 +1,20 @@
+import type { BaseHttpRequest } from './core/BaseHttpRequest';
+import type { OpenAPIConfig } from './core/OpenAPI';
+import { BlobsService } from './services.gen';
+import { ConfigurationsService } from './services.gen';
+import { ModelsService } from './services.gen';
+import { WorkerJobsService } from './services.gen';
+import { WorkersService } from './services.gen';
+import { WorkflowsService } from './services.gen';
+type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
+export declare class GeneratedClient {
+  readonly blobs: BlobsService;
+  readonly configurations: ConfigurationsService;
+  readonly models: ModelsService;
+  readonly workerJobs: WorkerJobsService;
+  readonly workers: WorkersService;
+  readonly workflows: WorkflowsService;
+  readonly request: BaseHttpRequest;
+  constructor(config?: Partial<OpenAPIConfig>, HttpRequest?: HttpRequestConstructor);
+}
+export {};

package/dist/generated/GeneratedClient.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedClient = void 0;
+const OpenAPI_1 = require("./core/OpenAPI");
+const FetchHttpRequest_1 = require("./core/FetchHttpRequest");
+const services_gen_1 = require("./services.gen");
+const services_gen_2 = require("./services.gen");
+const services_gen_3 = require("./services.gen");
+const services_gen_4 = require("./services.gen");
+const services_gen_5 = require("./services.gen");
+const services_gen_6 = require("./services.gen");
+class GeneratedClient {
+    constructor(config, HttpRequest = FetchHttpRequest_1.FetchHttpRequest) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        this.request = new HttpRequest({
+            BASE: (_a = config === null || config === void 0 ? void 0 : config.BASE) !== null && _a !== void 0 ? _a : '',
+            VERSION: (_b = config === null || config === void 0 ? void 0 : config.VERSION) !== null && _b !== void 0 ? _b : '2',
+            WITH_CREDENTIALS: (_c = config === null || config === void 0 ? void 0 : config.WITH_CREDENTIALS) !== null && _c !== void 0 ? _c : false,
+            CREDENTIALS: (_d = config === null || config === void 0 ? void 0 : config.CREDENTIALS) !== null && _d !== void 0 ? _d : 'include',
+            TOKEN: config === null || config === void 0 ? void 0 : config.TOKEN,
+            USERNAME: config === null || config === void 0 ? void 0 : config.USERNAME,
+            PASSWORD: config === null || config === void 0 ? void 0 : config.PASSWORD,
+            HEADERS: config === null || config === void 0 ? void 0 : config.HEADERS,
+            ENCODE_PATH: config === null || config === void 0 ? void 0 : config.ENCODE_PATH,
+            interceptors: {
+                request: (_f = (_e = config === null || config === void 0 ? void 0 : config.interceptors) === null || _e === void 0 ? void 0 : _e.request) !== null && _f !== void 0 ? _f : new OpenAPI_1.Interceptors(),
+                response: (_h = (_g = config === null || config === void 0 ? void 0 : config.interceptors) === null || _g === void 0 ? void 0 : _g.response) !== null && _h !== void 0 ? _h : new OpenAPI_1.Interceptors(),
+            },
+        });
+        this.blobs = new services_gen_1.BlobsService(this.request);
+        this.configurations = new services_gen_2.ConfigurationsService(this.request);
+        this.models = new services_gen_3.ModelsService(this.request);
+        this.workerJobs = new services_gen_4.WorkerJobsService(this.request);
+        this.workers = new services_gen_5.WorkersService(this.request);
+        this.workflows = new services_gen_6.WorkflowsService(this.request);
+    }
+}
+exports.GeneratedClient = GeneratedClient;

package/dist/generated/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: unknown;
+  readonly request: ApiRequestOptions;
+  constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}

package/dist/generated/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/generated/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, 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;
+  readonly errors?: Record<number, string>;
+};

package/dist/generated/core/ApiRequestOptions.js

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

package/dist/generated/core/ApiResult.d.ts

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

package/dist/generated/core/ApiResult.js

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

package/dist/generated/core/AxiosHttpRequest.d.ts

@@ -0,0 +1,14 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import { BaseHttpRequest } from './BaseHttpRequest';
+import type { CancelablePromise } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+export declare class AxiosHttpRequest extends BaseHttpRequest {
+  constructor(config: OpenAPIConfig);
+  /**
+   * Request method
+   * @param options The request options from the service
+   * @returns CancelablePromise<T>
+   * @throws ApiError
+   */
+  request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}

package/dist/generated/core/AxiosHttpRequest.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxiosHttpRequest = void 0;
+const BaseHttpRequest_1 = require("./BaseHttpRequest");
+const request_1 = require("./request");
+class AxiosHttpRequest extends BaseHttpRequest_1.BaseHttpRequest {
+    constructor(config) {
+        super(config);
+    }
+    /**
+     * Request method
+     * @param options The request options from the service
+     * @returns CancelablePromise<T>
+     * @throws ApiError
+     */
+    request(options) {
+        return (0, request_1.request)(this.config, options);
+    }
+}
+exports.AxiosHttpRequest = AxiosHttpRequest;

package/dist/generated/core/BaseHttpRequest.d.ts

@@ -0,0 +1,8 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { CancelablePromise } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+export declare abstract class BaseHttpRequest {
+  readonly config: OpenAPIConfig;
+  constructor(config: OpenAPIConfig);
+  abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}

package/dist/generated/core/BaseHttpRequest.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseHttpRequest = void 0;
+class BaseHttpRequest {
+    constructor(config) {
+        this.config = config;
+    }
+}
+exports.BaseHttpRequest = BaseHttpRequest;

package/dist/generated/core/CancelablePromise.d.ts

@@ -0,0 +1,37 @@
+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 _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: 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/dist/generated/core/CancelablePromise.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelablePromise = exports.CancelError = void 0;
+class CancelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CancelError';
+    }
+    get isCancelled() {
+        return true;
+    }
+}
+exports.CancelError = CancelError;
+class CancelablePromise {
+    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;
+            const onResolve = (value) => {
+                if (this._isResolved || this._isRejected || this._isCancelled) {
+                    return;
+                }
+                this._isResolved = true;
+                if (this._resolve)
+                    this._resolve(value);
+            };
+            const onReject = (reason) => {
+                if (this._isResolved || this._isRejected || this._isCancelled) {
+                    return;
+                }
+                this._isRejected = true;
+                if (this._reject)
+                    this._reject(reason);
+            };
+            const onCancel = (cancelHandler) => {
+                if (this._isResolved || this._isRejected || this._isCancelled) {
+                    return;
+                }
+                this.cancelHandlers.push(cancelHandler);
+            };
+            Object.defineProperty(onCancel, 'isResolved', {
+                get: () => this._isResolved,
+            });
+            Object.defineProperty(onCancel, 'isRejected', {
+                get: () => this._isRejected,
+            });
+            Object.defineProperty(onCancel, 'isCancelled', {
+                get: () => this._isCancelled,
+            });
+            return executor(onResolve, onReject, onCancel);
+        });
+    }
+    get [Symbol.toStringTag]() {
+        return 'Cancellable Promise';
+    }
+    then(onFulfilled, onRejected) {
+        return this.promise.then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return this.promise.catch(onRejected);
+    }
+    finally(onFinally) {
+        return this.promise.finally(onFinally);
+    }
+    cancel() {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+            return;
+        }
+        this._isCancelled = true;
+        if (this.cancelHandlers.length) {
+            try {
+                for (const cancelHandler of this.cancelHandlers) {
+                    cancelHandler();
+                }
+            }
+            catch (error) {
+                console.warn('Cancellation threw an error', error);
+                return;
+            }
+        }
+        this.cancelHandlers.length = 0;
+        if (this._reject)
+            this._reject(new CancelError('Request aborted'));
+    }
+    get isCancelled() {
+        return this._isCancelled;
+    }
+}
+exports.CancelablePromise = CancelablePromise;

package/dist/generated/core/FetchHttpRequest.d.ts

@@ -0,0 +1,14 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import { BaseHttpRequest } from './BaseHttpRequest';
+import type { CancelablePromise } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+export declare class FetchHttpRequest extends BaseHttpRequest {
+  constructor(config: OpenAPIConfig);
+  /**
+   * Request method
+   * @param options The request options from the service
+   * @returns CancelablePromise<T>
+   * @throws ApiError
+   */
+  request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}

package/dist/generated/core/FetchHttpRequest.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchHttpRequest = void 0;
+const BaseHttpRequest_1 = require("./BaseHttpRequest");
+const request_1 = require("./request");
+class FetchHttpRequest extends BaseHttpRequest_1.BaseHttpRequest {
+    constructor(config) {
+        super(config);
+    }
+    /**
+     * Request method
+     * @param options The request options from the service
+     * @returns CancelablePromise<T>
+     * @throws ApiError
+     */
+    request(options) {
+        return (0, request_1.request)(this.config, options);
+    }
+}
+exports.FetchHttpRequest = FetchHttpRequest;

package/dist/generated/core/OpenAPI.d.ts

@@ -0,0 +1,27 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+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;
+  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;
+  VERSION: string;
+  WITH_CREDENTIALS: boolean;
+  interceptors: {
+    request: Interceptors<RequestInit>;
+    response: Interceptors<Response>;
+  };
+};
+export declare const OpenAPI: OpenAPIConfig;
+export {};

package/dist/generated/core/OpenAPI.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPI = exports.Interceptors = void 0;
+class Interceptors {
+    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];
+    }
+}
+exports.Interceptors = Interceptors;
+exports.OpenAPI = {
+    BASE: '',
+    CREDENTIALS: 'include',
+    ENCODE_PATH: undefined,
+    HEADERS: undefined,
+    PASSWORD: undefined,
+    TOKEN: undefined,
+    USERNAME: undefined,
+    VERSION: '2',
+    WITH_CREDENTIALS: false,
+    interceptors: {
+        request: new Interceptors(),
+        response: new Interceptors(),
+    },
+};

package/dist/generated/core/request.d.ts

@@ -0,0 +1,49 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+import { CancelablePromise } from './CancelablePromise';
+import type { OnCancel } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+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: unknown) => value is FormData;
+export declare const base64: (str: string) => 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>
+) => Promise<T | undefined>;
+export declare const getHeaders: (
+  config: OpenAPIConfig,
+  options: ApiRequestOptions
+) => Promise<Headers>;
+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<unknown>;
+export declare const catchErrorCodes: (options: ApiRequestOptions, result: ApiResult) => void;
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+export declare const request: <T>(
+  config: OpenAPIConfig,
+  options: ApiRequestOptions
+) => CancelablePromise<T>;
+export {};