@newsletterstudio/umbraco 14.0.0-rc1

package/dist/backend-api/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/backend-api/core/ApiRequestOptions.d.ts

@@ -0,0 +1,14 @@
+export type ApiRequestOptions<T = unknown> = {
+    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 responseTransformer?: (data: unknown) => Promise<T>;
+    readonly errors?: Record<number | string, string>;
+};

package/dist/backend-api/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/backend-api/core/CancelablePromise.d.ts

@@ -0,0 +1,26 @@
+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/backend-api/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<T>) => 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/backend-api/core/request.d.ts

@@ -0,0 +1,29 @@
+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<T>) => Promise<T>;
+export declare const resolve: <T>(options: ApiRequestOptions<T>, resolver?: T | Resolver<T>) => Promise<T | undefined>;
+export declare const getHeaders: <T>(config: OpenAPIConfig, options: ApiRequestOptions<T>) => 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<T>) => CancelablePromise<T>;
+export {};

package/dist/backend-api/enums.gen.d.ts

@@ -0,0 +1,7 @@
+export declare const EventMessageTypeModelEnum: {
+    readonly DEFAULT: "Default";
+    readonly INFO: "Info";
+    readonly ERROR: "Error";
+    readonly SUCCESS: "Success";
+    readonly WARNING: "Warning";
+};

package/dist/backend-api/index.d.ts

@@ -0,0 +1,5 @@
+export { ApiError } from './core/ApiError';
+export { CancelablePromise, CancelError } from './core/CancelablePromise';
+export { OpenAPI, type OpenAPIConfig } from './core/OpenAPI';
+export * from './services.gen';
+export * from './types.gen';