@remkoj/optimizely-cms-api 6.0.0-rc.1 → 6.0.0-rc.4

package/AGENTS.md

@@ -0,0 +1,66 @@
+# @remkoj/optimizely-cms-api — usage
+
+CMS Integration REST API client for Optimizely SaaS CMS. CommonJS module.
+
+## Install
+
+```bash
+npm install @remkoj/optimizely-cms-api
+```
+
+## Environment variables
+
+| Variable | Required | Description |
+| --- | --- | --- |
+| `OPTIMIZELY_CMS_URL` | yes | CMS instance URL, e.g. `https://<tenant>.cms.optimizely.com` |
+| `OPTIMIZELY_CMS_CLIENT_ID` | yes | OAuth client ID |
+| `OPTIMIZELY_CMS_CLIENT_SECRET` | yes | OAuth client secret |
+| `OPTIMIZELY_CMS_API_BASEURL` | no | Override the API base URL |
+| `OPTIMIZELY_CMS_USER_ID` | no | Impersonate a specific user (`actAs`) |
+| `OPTIMIZELY_DEBUG` | no | Set to `"1"` to enable request/response logging |
+
+## Creating a client
+
+```typescript
+import { createClient, readEnvConfig } from '@remkoj/optimizely-cms-api'
+
+// From environment variables (recommended)
+const client = createClient()
+
+// With explicit config
+const client = createClient({
+  base: new URL('https://<tenant>.cms.optimizely.com'),
+  clientId: '...',
+  clientSecret: '...',
+  debug: false
+})
+```
+
+## Key exports
+
+| Export | Description |
+| --- | --- |
+| `createClient(config?)` | Creates a new API client instance. Reads env vars when config is omitted. |
+| `readEnvConfig()` | Reads and validates env vars into `CmsIntegrationApiOptions`. |
+| `readPartialEnvConfig()` | Reads env vars without requiring client credentials. |
+| `isClientInstance(value)` | Type guard for `CmsIntegrationApiClient`. |
+| `IntegrationApi.*` | All generated CMS API types (re-exported from `types.gen.ts`). |
+| `ContentRoots` | Enum of well-known content root node GUIDs (SystemRoot, Trash, etc.). |
+| `ApiClient` | Base client class. |
+| `ApiError` | Error thrown when an API operation fails. |
+| `ApiClientInstance` | Type alias for a client instance. |
+
+## Types
+
+```typescript
+import type { CmsIntegrationApiOptions, ApiClientInstance } from '@remkoj/optimizely-cms-api'
+import { IntegrationApi } from '@remkoj/optimizely-cms-api'
+
+// Use IntegrationApi.ContentType, IntegrationApi.DisplayTemplate, etc.
+```
+
+## Constraints
+
+- CommonJS module — works with both `require()` and `import`.
+- `ApiError` exposes `.status`, `.statusText`, `.data`, `.request`, `.response`.
+- `ContentRoots` values are GUIDs as strings.

package/dist/api-client.d.ts

@@ -1,46 +1,17 @@
+import { ApiClient as AbstractApiClient } from "@remkoj/hey-api-wrapper";
 import * as Operations from './client/sdk.gen';
-import { createClient, type RequestResult, type ResponseStyle } from './client/client';
+import { createClient } from './client/client';
 import { type CmsIntegrationApiOptions } from "./config";
-import { type InstanceApiVersionInfo, OptiCmsVersion } from "./types";
-type OperationsType = {
-    -readonly [KT in keyof typeof Operations]: (typeof Operations)[KT];
-};
-type OperationsNames = keyof OperationsType;
-type OperationReturnType<RT extends (...args: any) => any> = ReturnType<RT> extends RequestResult<any, any, boolean, ResponseStyle> ? Promise<NonNullable<Awaited<ReturnType<RT>>['data']>> : never;
-type ApiClientFunctions = {
-    readonly [KT in OperationsNames]: OperationsType[KT] extends Function ? (options?: Parameters<OperationsType[KT]>[0]) => OperationReturnType<OperationsType[KT]> : never;
-};
-type BaseClass = {
-    new (...args: any[]): BaseApiClient;
-};
-type NonConstructorKeys<T> = ({
-    [P in keyof T]: T[P] extends new () => any ? never : P;
-})[keyof T];
-type OmitConstructor<TBase extends BaseClass> = Pick<TBase, NonConstructorKeys<TBase>>;
-export type ClassWithMixin<TBase extends BaseClass, Mixin> = OmitConstructor<TBase> & {
-    new (...args: ConstructorParameters<TBase>): InstanceType<TBase> & Mixin;
-};
-declare class BaseApiClient {
-    protected _config: CmsIntegrationApiOptions;
-    protected _client: ReturnType<typeof createClient>;
+import type { OpenAPIV3_1 } from "openapi-types";
+/**
+ * Base implementation of the ApiClient wrapper for the Optimizely CMS Rest API
+ */
+declare class BaseApiClient extends AbstractApiClient<CmsIntegrationApiOptions, ReturnType<typeof createClient>> {
     constructor(config?: CmsIntegrationApiOptions);
-    /**
-     * Get the runtime configuration of the target CMS version.
-     *
-     * If this differs from the cmsVersion the client may not work fully or not
-     * at all.
-     *
-     * @deprecated  This is based on the OPTIMIZELY_CMS_SCHEMA environment that is ignored by API client
-     */
-    get runtimeCmsVersion(): OptiCmsVersion;
     /**
      * The URL of the CMS instance
      */
     get cmsUrl(): URL | undefined;
-    /**
-     * Marker to indicate if the client has debugging enabled
-     */
-    get debug(): boolean;
     /**
      * Detect the API Version from the URL, returning the runtime version. When
      * this version differs from the `apiVersion` property errors can be expected.
@@ -54,37 +25,11 @@ declare class BaseApiClient {
      * The CMS version for which this client was build
      */
     get cmsVersion(): string;
-    /**
-     * Retrieve the version information
-     *
-     * @returns The version information from the running instance
-     */
-    getInstanceInfo(): Promise<InstanceApiVersionInfo>;
-    getOpenApiSpec(): Promise<any>;
+    getOpenApiSpec(): Promise<OpenAPIV3_1.Document>;
     getSchemaItemBase(): URL | undefined;
 }
-export declare class ApiError extends Error {
-    protected _ctx: {
-        error: unknown;
-        request: Request;
-        response: Response;
-    };
-    constructor(data: {
-        error: unknown;
-        request: Request;
-        response: Response;
-    });
-    get data(): unknown;
-    /**
-     * @deprecated use data() instead
-     */
-    get body(): unknown;
-    get request(): unknown;
-    get response(): unknown;
-    get status(): number;
-    get statusText(): string;
-}
-export declare const ApiClient: ClassWithMixin<typeof BaseApiClient, ApiClientFunctions>;
+export { ApiError } from "@remkoj/hey-api-wrapper";
+export declare const ApiClient: import("@remkoj/hey-api-wrapper/dist/types").ClassWithMixin<typeof BaseApiClient, import("@remkoj/hey-api-wrapper/dist/types").ApiClientFunctions<typeof Operations>>;
 export type ApiClientStatic = typeof ApiClient;
 export type CmsIntegrationApiClient = InstanceType<typeof ApiClient>;
 export default ApiClient;

package/dist/api-client.js

@@ -37,77 +37,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiClient = exports.ApiError = void 0;
+const hey_api_wrapper_1 = require("@remkoj/hey-api-wrapper");
 const Operations = __importStar(require("./client/sdk.gen"));
 const client_1 = require("./client/client");
-const config_1 = require("./config");
-const types_1 = require("./types");
 const client_config_1 = require("./client-config");
+const config_1 = require("./config");
 const version_json_1 = __importDefault(require("./version.json"));
-function applyOperations(Base) {
-    // Create the new class
-    class NewClass extends Base {
-        constructor(...args) {
-            super(...args);
-        }
-    }
-    // Bind the operations
-    Object.getOwnPropertyNames(Operations).filter(isApiClientFunction).forEach(propName => {
-        async function wrapper(args) {
-            const operationArgs = {
-                throwOnError: false,
-                ...args,
-                //@ts-expect-error
-                client: this._client
-            };
-            //@ts-expect-error
-            const result = await Operations[propName](operationArgs);
-            if (result.data)
-                return result.data;
-            throw new ApiError(result);
-        }
-        //@ts-expect-error
-        NewClass.prototype[propName] = wrapper;
-    });
-    // Return the new class
-    return NewClass;
-}
-function createIsFunctionValidator(baseType) {
-    return (propName) => {
-        return typeof (baseType[propName]) == 'function';
-    };
-}
-const isApiClientFunction = createIsFunctionValidator(Operations);
-class BaseApiClient {
-    _config;
-    _client;
+/**
+ * Base implementation of the ApiClient wrapper for the Optimizely CMS Rest API
+ */
+class BaseApiClient extends hey_api_wrapper_1.ApiClient {
     constructor(config) {
-        // Store instance variables
-        this._config = config ?? (0, config_1.readEnvConfig)();
-        this._client = (0, client_1.createClient)((0, client_config_1.createClientConfig)((0, client_1.createConfig)({
-            baseUrl: 'https://api.cms.optimizely.com/preview3',
-        }), this._config));
-        // Configure Client
-        if (this._config.debug) {
-            this._client.interceptors.request.use(async (request) => {
-                console.log(`🔍 [CMS API] Sending ${request.method} request to ${request.url}`);
-                return request;
-            });
-            this._client.interceptors.response.use((response, request) => {
-                console.log(`✨ [CMS API] Received response ${response.status} ${response.statusText} of type ${response.headers.get('Content-Type') ?? 'unknown'} for ${request.url}`);
-                return response;
-            });
-        }
-    }
-    /**
-     * Get the runtime configuration of the target CMS version.
-     *
-     * If this differs from the cmsVersion the client may not work fully or not
-     * at all.
-     *
-     * @deprecated  This is based on the OPTIMIZELY_CMS_SCHEMA environment that is ignored by API client
-     */
-    get runtimeCmsVersion() {
-        return this._config.cmsVersion ?? types_1.OptiCmsVersion.CMSSAAS;
+        const apiConfig = config ?? (0, config_1.readEnvConfig)();
+        const apiClient = (0, client_1.createClient)((0, client_config_1.createClientConfig)((0, client_1.createConfig)({
+            baseUrl: 'https://api.cms.optimizely.com/v1',
+        }), config));
+        super(apiConfig, apiClient);
     }
     /**
      * The URL of the CMS instance
@@ -118,19 +63,13 @@ class BaseApiClient {
         const baseUrl = this._client.getConfig().baseUrl;
         return baseUrl ? new URL(baseUrl) : undefined;
     }
-    /**
-     * Marker to indicate if the client has debugging enabled
-     */
-    get debug() {
-        return this._config.debug ?? false;
-    }
     /**
      * Detect the API Version from the URL, returning the runtime version. When
      * this version differs from the `apiVersion` property errors can be expected.
      */
     get version() {
         const baseUrl = this._client.getConfig().baseUrl;
-        const detectedVersion = baseUrl?.match(/^https{0,1}:\/\/.+?\/(_cms\/){0,1}([a-z0-9\.]+)(\/|$)/)?.at(2);
+        const detectedVersion = baseUrl?.match(/^https{0,1}:\/\/.+?\/(_cms\/){0,1}([a-z0-9.]+)(\/|$)/)?.at(2);
         return detectedVersion || "";
     }
     /**
@@ -145,29 +84,14 @@ class BaseApiClient {
     get cmsVersion() {
         return version_json_1.default.cms;
     }
-    /**
-     * Retrieve the version information
-     *
-     * @returns The version information from the running instance
-     */
-    async getInstanceInfo() {
-        const result = await this._client.get({
-            url: '/info'
-        });
-        if (result.data) {
-            const data = result.data;
-            data.baseUrl = this._client.getConfig().baseUrl;
-            return data;
-        }
-        throw new ApiError(result);
-    }
     async getOpenApiSpec() {
         const result = await this._client.get({
             url: '/docs/content-openapi.json',
+            throwOnError: false
         });
-        if (result.data)
+        if (this.isDataResponse(result))
             return result.data;
-        throw new ApiError(result);
+        throw new hey_api_wrapper_1.ApiError(result);
     }
     getSchemaItemBase() {
         let baseUrl = this._client.getConfig().baseUrl;
@@ -176,37 +100,7 @@ class BaseApiClient {
         return baseUrl ? new URL(baseUrl) : undefined;
     }
 }
-class ApiError extends Error {
-    _ctx;
-    constructor(data) {
-        if (typeof data.error == 'string')
-            super(data.error);
-        else
-            super(`Optimizely CMS API Error: ${data.response.status} ${data.response.statusText}`);
-        this._ctx = data;
-    }
-    get data() {
-        return this._ctx.error;
-    }
-    /**
-     * @deprecated use data() instead
-     */
-    get body() {
-        return this._ctx.error;
-    }
-    get request() {
-        return this._ctx.request;
-    }
-    get response() {
-        return this._ctx.response;
-    }
-    get status() {
-        return this._ctx.response.status;
-    }
-    get statusText() {
-        return this._ctx.response.statusText;
-    }
-}
-exports.ApiError = ApiError;
-exports.ApiClient = applyOperations(BaseApiClient);
+var hey_api_wrapper_2 = require("@remkoj/hey-api-wrapper");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return hey_api_wrapper_2.ApiError; } });
+exports.ApiClient = (0, hey_api_wrapper_1.withOperations)(BaseApiClient, Operations);
 exports.default = exports.ApiClient;

package/dist/client/client/client.gen.js

@@ -22,10 +22,7 @@ const createClient = (config = {}) => {
             serializedBody: undefined,
         };
         if (opts.security) {
-            await (0, utils_gen_2.setAuthParams)({
-                ...opts,
-                security: opts.security,
-            });
+            await (0, utils_gen_2.setAuthParams)(opts);
         }
         if (opts.requestValidator) {
             await opts.requestValidator(opts);
@@ -37,154 +34,139 @@ const createClient = (config = {}) => {
         if (opts.body === undefined || opts.serializedBody === '') {
             opts.headers.delete('Content-Type');
         }
-        const url = (0, utils_gen_2.buildUrl)(opts);
-        return { opts, url };
+        const resolvedOpts = opts;
+        const url = (0, utils_gen_2.buildUrl)(resolvedOpts);
+        return { opts: resolvedOpts, url };
     };
     const request = async (options) => {
-        // @ts-expect-error
-        const { opts, url } = await beforeRequest(options);
-        const requestInit = {
-            redirect: 'follow',
-            ...opts,
-            body: (0, utils_gen_1.getValidRequestBody)(opts),
-        };
-        let request = new Request(url, requestInit);
-        for (const fn of interceptors.request.fns) {
-            if (fn) {
-                request = await fn(request, opts);
-            }
-        }
-        // fetch must be assigned here, otherwise it would throw the error:
-        // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
-        const _fetch = opts.fetch;
+        const throwOnError = options.throwOnError ?? _config.throwOnError;
+        const responseStyle = options.responseStyle ?? _config.responseStyle;
+        let request;
         let response;
         try {
-            response = await _fetch(request);
-        }
-        catch (error) {
-            // Handle fetch exceptions (AbortError, network errors, etc.)
-            let finalError = error;
-            for (const fn of interceptors.error.fns) {
+            const { opts, url } = await beforeRequest(options);
+            const requestInit = {
+                redirect: 'follow',
+                ...opts,
+                body: (0, utils_gen_1.getValidRequestBody)(opts),
+            };
+            request = new Request(url, requestInit);
+            for (const fn of interceptors.request.fns) {
                 if (fn) {
-                    finalError = (await fn(error, undefined, request, opts));
+                    request = await fn(request, opts);
                 }
             }
-            finalError = finalError || {};
-            if (opts.throwOnError) {
-                throw finalError;
-            }
-            // Return error response
-            return opts.responseStyle === 'data'
-                ? undefined
-                : {
-                    error: finalError,
-                    request,
-                    response: undefined,
-                };
-        }
-        for (const fn of interceptors.response.fns) {
-            if (fn) {
-                response = await fn(response, request, opts);
+            // fetch must be assigned here, otherwise it would throw the error:
+            // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+            const _fetch = opts.fetch;
+            response = await _fetch(request);
+            for (const fn of interceptors.response.fns) {
+                if (fn) {
+                    response = await fn(response, request, opts);
+                }
             }
-        }
-        const result = {
-            request,
-            response,
-        };
-        if (response.ok) {
-            const parseAs = (opts.parseAs === 'auto'
-                ? (0, utils_gen_2.getParseAs)(response.headers.get('Content-Type'))
-                : opts.parseAs) ?? 'json';
-            if (response.status === 204 || response.headers.get('Content-Length') === '0') {
-                let emptyData;
+            const result = {
+                request,
+                response,
+            };
+            if (response.ok) {
+                const parseAs = (opts.parseAs === 'auto'
+                    ? (0, utils_gen_2.getParseAs)(response.headers.get('Content-Type'))
+                    : opts.parseAs) ?? 'json';
+                if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+                    let emptyData;
+                    switch (parseAs) {
+                        case 'arrayBuffer':
+                        case 'blob':
+                        case 'text':
+                            emptyData = await response[parseAs]();
+                            break;
+                        case 'formData':
+                            emptyData = new FormData();
+                            break;
+                        case 'stream':
+                            emptyData = response.body;
+                            break;
+                        case 'json':
+                        default:
+                            emptyData = {};
+                            break;
+                    }
+                    return opts.responseStyle === 'data'
+                        ? emptyData
+                        : {
+                            data: emptyData,
+                            ...result,
+                        };
+                }
+                let data;
                 switch (parseAs) {
                     case 'arrayBuffer':
                     case 'blob':
+                    case 'formData':
                     case 'text':
-                        emptyData = await response[parseAs]();
+                        data = await response[parseAs]();
                         break;
-                    case 'formData':
-                        emptyData = new FormData();
+                    case 'json': {
+                        // Some servers return 200 with no Content-Length and empty body.
+                        // response.json() would throw; read as text and parse if non-empty.
+                        const text = await response.text();
+                        data = text ? JSON.parse(text) : {};
                         break;
+                    }
                     case 'stream':
-                        emptyData = response.body;
-                        break;
-                    case 'json':
-                    default:
-                        emptyData = {};
-                        break;
+                        return opts.responseStyle === 'data'
+                            ? response.body
+                            : {
+                                data: response.body,
+                                ...result,
+                            };
+                }
+                if (parseAs === 'json') {
+                    if (opts.responseValidator) {
+                        await opts.responseValidator(data);
+                    }
+                    if (opts.responseTransformer) {
+                        data = await opts.responseTransformer(data);
+                    }
                 }
                 return opts.responseStyle === 'data'
-                    ? emptyData
+                    ? data
                     : {
-                        data: emptyData,
+                        data,
                         ...result,
                     };
             }
-            let data;
-            switch (parseAs) {
-                case 'arrayBuffer':
-                case 'blob':
-                case 'formData':
-                case 'text':
-                    data = await response[parseAs]();
-                    break;
-                case 'json': {
-                    // Some servers return 200 with no Content-Length and empty body.
-                    // response.json() would throw; read as text and parse if non-empty.
-                    const text = await response.text();
-                    data = text ? JSON.parse(text) : {};
-                    break;
-                }
-                case 'stream':
-                    return opts.responseStyle === 'data'
-                        ? response.body
-                        : {
-                            data: response.body,
-                            ...result,
-                        };
+            const textError = await response.text();
+            let jsonError;
+            try {
+                jsonError = JSON.parse(textError);
             }
-            if (parseAs === 'json') {
-                if (opts.responseValidator) {
-                    await opts.responseValidator(data);
-                }
-                if (opts.responseTransformer) {
-                    data = await opts.responseTransformer(data);
+            catch {
+                // noop
+            }
+            throw jsonError ?? textError;
+        }
+        catch (error) {
+            let finalError = error;
+            for (const fn of interceptors.error.fns) {
+                if (fn) {
+                    finalError = await fn(finalError, response, request, options);
                 }
             }
-            return opts.responseStyle === 'data'
-                ? data
+            finalError = finalError || {};
+            if (throwOnError) {
+                throw finalError;
+            }
+            // TODO: we probably want to return error and improve types
+            return responseStyle === 'data'
+                ? undefined
                 : {
-                    data,
-                    ...result,
+                    error: finalError,
+                    request,
+                    response,
                 };
         }
-        const textError = await response.text();
-        let jsonError;
-        try {
-            jsonError = JSON.parse(textError);
-        }
-        catch {
-            // noop
-        }
-        const error = jsonError ?? textError;
-        let finalError = error;
-        for (const fn of interceptors.error.fns) {
-            if (fn) {
-                finalError = (await fn(error, response, request, opts));
-            }
-        }
-        finalError = finalError || {};
-        if (opts.throwOnError) {
-            throw finalError;
-        }
-        // TODO: we probably want to return error and improve types
-        return opts.responseStyle === 'data'
-            ? undefined
-            : {
-                error: finalError,
-                ...result,
-            };
     };
     const makeMethodFn = (method) => (options) => request({ ...options, method });
     const makeSseFn = (method) => async (options) => {
@@ -192,7 +174,6 @@ const createClient = (config = {}) => {
         return (0, serverSentEvents_gen_1.createSseClient)({
             ...opts,
             body: opts.body,
-            headers: opts.headers,
             method,
             onRequest: async (url, init) => {
                 let request = new Request(url, init);

package/dist/client/client/index.d.ts

@@ -3,6 +3,8 @@ export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
 export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.gen';
 export { buildClientParams } from '../core/params.gen';
 export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export type { ServerSentEventsResult } from '../core/serverSentEvents.gen';
+export type { ClientMeta } from '../core/types.gen';
 export { createClient } from './client.gen';
 export type { Client, ClientOptions, Config, CreateClientConfig, Options, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from './types.gen';
 export { createConfig, mergeHeaders } from './utils.gen';

package/dist/client/client/types.gen.d.ts

@@ -63,6 +63,7 @@ export interface RequestOptions<TData = unknown, TResponseStyle extends Response
     url: Url;
 }
 export interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    headers: Headers;
     serializedBody?: string;
 }
 export type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
@@ -76,8 +77,10 @@ export type RequestResult<TData = unknown, TError = unknown, ThrowOnError extend
     data: undefined;
     error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
 }) & {
-    request: Request;
-    response: Response;
+    /** request may be undefined, because error may be from building the request object itself */
+    request?: Request;
+    /** response may be undefined, because error may be from building the request object itself or from a network error */
+    response?: Response;
 }>;
 export interface ClientOptions {
     baseUrl?: string;
@@ -85,7 +88,7 @@ export interface ClientOptions {
     throwOnError?: boolean;
 }
 type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData>>;
 type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
 type BuildUrlFn = <TData extends {
     body?: unknown;