@fencyai/js 0.1.41 → 0.1.43

package/lib/api/createChatCompletion.d.ts

@@ -1,10 +1,6 @@
 import { ApiError } from '../types/ApiError';
 import { ChatCompletion } from '../types/ChatCompletion';
 import { CreateChatCompletionRequest } from '../types/CreateChatCompletionRequest';
-export interface CreateChatCompletionOptions {
-    apiUrl?: string;
-    request: CreateChatCompletionRequest;
-}
 /**
  * Creates a chat completion by making a POST request to the Fency API.
  *

package/lib/api/createChatCompletion.js

@@ -1,46 +1,32 @@
-import { isApiError } from '../types/ApiError';
-import { isChatCompletion } from '../types/ChatCompletion';
+import { OpenAPI, PubService } from '../openapi';
 import { getPackageVersion } from '../utils/version';
 export async function createChatCompletion(params) {
-    const apiUrl = `${params.baseUrl}/v1/pub/chat-completions`;
-    console.log('request', params.request);
-    const response = await fetch(apiUrl, {
-        method: 'POST',
-        headers: {
+    try {
+        OpenAPI.BASE = params.baseUrl;
+        OpenAPI.HEADERS = {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${params.pk}`,
             'X-Fency-Sdk-Version': getPackageVersion(),
-        },
-        body: JSON.stringify(params.request),
-    });
-    if (!response.ok) {
-        const error = await response.json();
-        if (isApiError(error)) {
-            return {
-                type: 'error',
-                error,
-            };
-        }
+        };
+        const response = await PubService.createChatCompletion(params.request);
         return {
-            type: 'error',
-            error: {
-                code: 'UnknownError',
-                message: `Unknown error: ${JSON.stringify(error)}`,
+            type: 'success',
+            completion: {
+                id: response.id,
+                createdAt: response.createdAt,
+                streamId: response.streamId ?? undefined,
+                response: response.response ?? undefined,
+                responseIsStructured: response.responseIsStructured ?? undefined,
             },
         };
     }
-    const completion = await response.json();
-    if (!isChatCompletion(completion)) {
+    catch (error) {
         return {
             type: 'error',
             error: {
-                code: 'InvalidResponse',
-                message: `Invalid chat completion response: ${JSON.stringify(completion)}`,
+                code: 'UnknownError',
+                message: `Unknown error!\n${error ? `Error: ${error}\n` : ''}`.trim(),
             },
         };
     }
-    return {
-        type: 'success',
-        completion,
-    };
 }

package/lib/api/createStream.d.ts

@@ -0,0 +1,14 @@
+import { CreateStreamRequest, CreateStreamResponse } from '..';
+/**
+ * Creates a new stream by making a POST request to the Fency API.
+ *
+ * @param pk - The publishable key (used as Bearer token and default name)
+ * @param options - Optional configuration (apiUrl, name)
+ * @returns A promise that resolves to a Stream
+ * @throws Error if the request fails or the response is invalid
+ */
+export declare function createStream(params: {
+    pk: string;
+    request: CreateStreamRequest;
+    baseUrl: string;
+}): Promise<CreateStreamResponse>;

package/lib/api/createStream.js

@@ -0,0 +1,53 @@
+import { OpenAPI, PubService, StreamType } from '../openapi';
+import { getPackageVersion } from '../utils/version';
+/**
+ * Creates a new stream by making a POST request to the Fency API.
+ *
+ * @param pk - The publishable key (used as Bearer token and default name)
+ * @param options - Optional configuration (apiUrl, name)
+ * @returns A promise that resolves to a Stream
+ * @throws Error if the request fails or the response is invalid
+ */
+export async function createStream(params) {
+    try {
+        OpenAPI.BASE = params.baseUrl;
+        OpenAPI.HEADERS = {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${params.pk}`,
+            'X-Fency-Sdk-Version': getPackageVersion(),
+        };
+        const response = await PubService.createStream({
+            type: mapTypeToStreamType(params.request.type),
+            chatCompletionStream: params.request.type === 'ChatCompletionStream'
+                ? {
+                    clientSecret: params.request.chatCompletionStreamOptions
+                        ?.sessionClientSecret,
+                }
+                : undefined,
+        });
+        return {
+            type: 'success',
+            stream: {
+                id: response.id,
+                createdAt: response.createdAt,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            type: 'error',
+            error: {
+                code: 'UnknownError',
+                message: `Unknown error!\n${error ? `Error: ${error}\n` : ''}`.trim(),
+            },
+        };
+    }
+}
+const mapTypeToStreamType = (type) => {
+    switch (type) {
+        case 'ChatCompletionStream':
+            return StreamType.CHAT_COMPLETION_STREAM;
+        case 'FileUploadStream':
+            return StreamType.FILE_UPLOAD_STREAM;
+    }
+};

package/lib/api/createUpload.d.ts

@@ -0,0 +1,16 @@
+import { CreateUploadRequest } from '../types/CreateUploadRequest';
+import { CreateUploadResponse } from '../types/CreateUploadResponse';
+/**
+ * Creates a website by making a POST request to the Fency API.
+ *
+ * @param pk - The publishable key (used as Bearer token)
+ * @param request - The request body
+ * @param options - Optional configuration (apiUrl, request overrides)
+ * @returns A promise that resolves to a CreateWebsiteResponse
+ * @throws Error if the request fails or the response is invalid
+ */
+export declare function createUpload(params: {
+    pk: string;
+    request: CreateUploadRequest;
+    baseUrl: string;
+}): Promise<CreateUploadResponse>;

package/lib/api/createUpload.js

@@ -0,0 +1,53 @@
+import { OpenAPI, PubService } from '../openapi';
+import { getPackageVersion } from '../utils/version';
+/**
+ * Creates a website by making a POST request to the Fency API.
+ *
+ * @param pk - The publishable key (used as Bearer token)
+ * @param request - The request body
+ * @param options - Optional configuration (apiUrl, request overrides)
+ * @returns A promise that resolves to a CreateWebsiteResponse
+ * @throws Error if the request fails or the response is invalid
+ */
+export async function createUpload(params) {
+    try {
+        OpenAPI.BASE = params.baseUrl;
+        OpenAPI.HEADERS = {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${params.pk}`,
+            'X-Fency-Sdk-Version': getPackageVersion(),
+        };
+        const response = await PubService.createUpload({
+            streamId: params.request.streamId,
+            fileName: params.request.fileName,
+            mimeType: params.request.fileType,
+            fileSize: params.request.fileSize,
+        });
+        return {
+            type: 'success',
+            upload: {
+                id: response.id,
+                createdAt: response.createdAt,
+                s3PostRequest: {
+                    xAmzDate: response.s3PostRequest.amzDate,
+                    xAmzSignature: response.s3PostRequest.amzSignature,
+                    xAmzAlgorithm: response.s3PostRequest.amzAlgorithm,
+                    xAmzCredential: response.s3PostRequest.amzCredential,
+                    policy: response.s3PostRequest.policy,
+                    key: response.s3PostRequest.key,
+                    uploadUrl: response.s3PostRequest.uploadUrl,
+                    sessionToken: response.s3PostRequest.sessionToken,
+                },
+            },
+        };
+    }
+    catch (error) {
+        return {
+            type: 'error',
+            error: {
+                code: 'UnknownError',
+                message: `Unknown error!\n${error ? `Error: ${error}\n` : ''}`.trim(),
+            },
+        };
+    }
+}

package/lib/api/createWebsite.d.ts

@@ -0,0 +1,16 @@
+import { CreateWebsiteRequest } from '../types/CreateWebsiteRequest';
+import { CreateWebsiteResponse } from '../types/CreateWebsiteResponse';
+/**
+ * Creates a website by making a POST request to the Fency API.
+ *
+ * @param pk - The publishable key (used as Bearer token)
+ * @param request - The request body
+ * @param options - Optional configuration (apiUrl, request overrides)
+ * @returns A promise that resolves to a CreateWebsiteResponse
+ * @throws Error if the request fails or the response is invalid
+ */
+export declare function createWebsite(params: {
+    pk: string;
+    request: CreateWebsiteRequest;
+    baseUrl: string;
+}): Promise<CreateWebsiteResponse>;

package/lib/api/createWebsite.js

@@ -0,0 +1,39 @@
+import { OpenAPI, PubService } from '../openapi';
+import { getPackageVersion } from '../utils/version';
+/**
+ * Creates a website by making a POST request to the Fency API.
+ *
+ * @param pk - The publishable key (used as Bearer token)
+ * @param request - The request body
+ * @param options - Optional configuration (apiUrl, request overrides)
+ * @returns A promise that resolves to a CreateWebsiteResponse
+ * @throws Error if the request fails or the response is invalid
+ */
+export async function createWebsite(params) {
+    try {
+        OpenAPI.BASE = params.baseUrl;
+        OpenAPI.HEADERS = {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${params.pk}`,
+            'X-Fency-Sdk-Version': getPackageVersion(),
+        };
+        const response = await PubService.createWebsite(params.request);
+        return {
+            type: 'success',
+            website: {
+                id: response.id,
+                createdAt: response.createdAt,
+                content: response.content,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            type: 'error',
+            error: {
+                code: 'UnknownError',
+                message: `Unknown error!\n${error ? `Error: ${error}\n` : ''}`.trim(),
+            },
+        };
+    }
+}

package/lib/index.d.ts

@@ -1,24 +1,37 @@
 import { createChatCompletion } from './api/createChatCompletion';
-import { createChatCompletionStream } from './api/createChatCompletionStream';
+import { createStream } from './api/createStream';
 import { loadFency } from './loadFency';
-export type { FencyInstance, FencyOptions, } from './types';
+export type { FencyInstance, FencyOptions } from './types';
+export type { AnthropicModel } from './types/AnthropicModel';
 export type { ChatCompletion, isChatCompletion } from './types/ChatCompletion';
 export type { ChatCompletionMessage } from './types/ChatCompletionMessage';
-export type { ChatCompletionStream } from './types/ChatCompletionStream';
-export type { CreateChatCompletionRequest } from './types/CreateChatCompletionRequest';
 export type { CreateAnthropicChatCompletionParams } from './types/CreateAnthropicChatCompletionParams';
+export type { CreateChatCompletionRequest } from './types/CreateChatCompletionRequest';
 export type { CreateGeminiChatCompletionParams } from './types/CreateGeminiChatCompletionParams';
 export type { CreateOpenAiChatCompletionParams } from './types/CreateOpenAiChatCompletionParams';
-export type { AnthropicModel } from './types/AnthropicModel';
+export type { CreateStreamRequest } from './types/CreateStreamRequest';
+export type { CreateStreamResponse } from './types/CreateStreamResponse';
+export type { CreateWebsiteRequest } from './types/CreateWebsiteRequest';
+export type { FencyUpload } from './types/FencyUpload';
+export type { FencyWebsite } from './types/FencyWebsite';
 export type { GeminiModel } from './types/GeminiModel';
 export type { OpenAiModel } from './types/OpenAiModel';
+export type { Stream } from './types/Stream';
 export { createChatCompletion } from './api/createChatCompletion';
-export type { CreateChatCompletionOptions } from './api/createChatCompletion';
-export { createChatCompletionStream } from './api/createChatCompletionStream';
+export type { CreateChatCompletionResponse } from './api/createChatCompletion';
+export { createUpload } from './api/createUpload';
+export type { CreateUploadRequest } from './types/CreateUploadRequest';
+export type { CreateUploadResponse } from './types/CreateUploadResponse';
+export type { FencyFile } from './types/FencyFile';
+export { createStream } from './api/createStream';
+export type { ChatCompletionStreamCompleted, FileUploadCompleted, NewChatCompletionStreamChunk, StreamData, StreamNotFound, StreamTimeout, } from './types/StreamData';
+export { createWebsite } from './api/createWebsite';
+export type { CreateWebsiteResponse } from './types/CreateWebsiteResponse';
 export { loadFency } from './loadFency';
+export type { ApiError } from './types/ApiError';
 declare const _default: {
     loadFency: typeof loadFency;
     createChatCompletion: typeof createChatCompletion;
-    createChatCompletionStream: typeof createChatCompletionStream;
+    createStream: typeof createStream;
 };
 export default _default;

package/lib/index.js

@@ -2,15 +2,21 @@
 // This is the base library that provides the loadFency method
 // Import main functions
 import { createChatCompletion } from './api/createChatCompletion';
-import { createChatCompletionStream } from './api/createChatCompletionStream';
+import { createStream } from './api/createStream';
 import { loadFency } from './loadFency';
-// Re-export main functions
+// create chat completion
 export { createChatCompletion } from './api/createChatCompletion';
-export { createChatCompletionStream } from './api/createChatCompletionStream';
+// uploads
+export { createUpload } from './api/createUpload';
+// create chat completion stream
+export { createStream } from './api/createStream';
+// create website
+export { createWebsite } from './api/createWebsite';
+// load fency
 export { loadFency } from './loadFency';
 // Default export for convenience
 export default {
     loadFency,
     createChatCompletion,
-    createChatCompletionStream,
+    createStream,
 };

package/lib/openapi/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/lib/openapi/core/ApiError.js

@@ -0,0 +1,11 @@
+export 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;
+    }
+}

package/lib/openapi/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/lib/openapi/core/ApiRequestOptions.js

@@ -0,0 +1 @@
+export {};

package/lib/openapi/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/lib/openapi/core/ApiResult.js

@@ -0,0 +1 @@
+export {};

package/lib/openapi/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/lib/openapi/core/CancelablePromise.js

@@ -0,0 +1,111 @@
+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;
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export class CancelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CancelError';
+    }
+    get isCancelled() {
+        return true;
+    }
+}
+export 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) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isResolved, true, "f");
+                if (__classPrivateFieldGet(this, _CancelablePromise_resolve, "f"))
+                    __classPrivateFieldGet(this, _CancelablePromise_resolve, "f").call(this, value);
+            };
+            const onReject = (reason) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isRejected, true, "f");
+                if (__classPrivateFieldGet(this, _CancelablePromise_reject, "f"))
+                    __classPrivateFieldGet(this, _CancelablePromise_reject, "f").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() {
+        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;
+        if (__classPrivateFieldGet(this, _CancelablePromise_reject, "f"))
+            __classPrivateFieldGet(this, _CancelablePromise_reject, "f").call(this, new CancelError('Request aborted'));
+    }
+    get isCancelled() {
+        return __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f");
+    }
+}

package/lib/openapi/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/lib/openapi/core/OpenAPI.js

@@ -0,0 +1,11 @@
+export const OpenAPI = {
+    BASE: '',
+    VERSION: '1.0',
+    WITH_CREDENTIALS: false,
+    CREDENTIALS: 'include',
+    TOKEN: undefined,
+    USERNAME: undefined,
+    PASSWORD: undefined,
+    HEADERS: undefined,
+    ENCODE_PATH: undefined,
+};

package/lib/openapi/core/request.d.ts

@@ -0,0 +1,30 @@
+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 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 isBlob: (value: any) => value is Blob;
+export declare const isFormData: (value: any) => value is FormData;
+export declare const base64: (str: string) => string;
+export declare const getQueryString: (params: Record<string, any>) => 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) => any;
+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 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 {};