@remkoj/optimizely-cms-api 5.1.5 → 6.0.0-pre10

package/README.md

@@ -17,13 +17,12 @@ import createClient, { ContentRoots } from '@remkoj/optimizely-cms-integration-a
 
 // Create an instance of the client
 const client = createClient({
-    base: "https://example.com",
     clientId: "apiClientID",
     clientSecret: "apiClientSecret"
 });
 
 // Start using client
-client.content.contentListItems(ContentRoots.SystemRoot).then(response => {
+client.preview2ContentList(ContentRoots.SystemRoot).then(response => {
     const items = response.items
     items?.map(item => {
         // Do something with the item
@@ -38,8 +37,7 @@ The configuration object for the `createClient()` method is optional, if it is o
 The following configuration options are available for 
 | Environment variable | Configuration key | Required | Usage |
 | --- | --- | --- | --- |
-| OPTIMIZELY_CMS_URL | base | yes | The URL where the CMS is available |
+| OPTIMIZELY_CMS_URL | base | no | Sets the URL of the Optimizely CMS instance |
 | OPTIMIZELY_CMS_CLIENT_ID | clientId | yes | The API Client ID, as configured within the CMS |
 | OPTIMIZELY_CMS_CLIENT_SECRET | clientSecret | yes | The API Client Secret as generated by the CMS when creating the client |
-| OPTIMIZELY_CMS_USER_ID | actAs | no | The username of the CMS user to impersonate |
-| OPTIMIZELY_CMS_SCHEMA | cmsVersion | no | Override the target Optimizely CMS Version:<br/><br/>`OPTI-CMS-12`: Optimizely CMS 12, With [CMS Service Preview 1](https://nuget.optimizely.com/package/?id=Optimizely.Cms.Preview1.Service) installed and working.<br/><br/>`OPTI-CMS-13`: Optimizely SaaS CMS / CMS 13<br/><br/>**Default:** SaaS CMS / CMS 13 |
+| OPTIMIZELY_CMS_USER_ID | actAs | no | The username of the CMS user to impersonate |

package/dist/api-client.d.ts

@@ -1,30 +1,62 @@
-import { CmsIntegrationApiClient } from "./client";
+import * as Operations from './client/sdk.gen';
+import { createClient, type RequestResult, type ResponseStyle } from './client/client';
+import * as InstanceOperations from './instance.client/sdk.gen';
+import { createClient as createInstanceClient, type RequestResult as InstanceRequestResult, type ResponseStyle as InstanceResponseStyle } from './instance.client/client';
 import { type CmsIntegrationApiOptions } from "./config";
 import { type InstanceApiVersionInfo, OptiCmsVersion } from "./types";
-import type { CancelablePromise } from "./client";
-export declare class ApiClient extends CmsIntegrationApiClient {
-    private _config;
-    /**
-     * Create a new instance of the API Client
-     *
-     * @param   config  The instance configuration
-     */
+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 InstanceOperationsType = {
+    -readonly [KT in keyof typeof InstanceOperations]: (typeof InstanceOperations)[KT];
+};
+type InstanceOperationsNames = keyof InstanceOperationsType;
+type InstanceOperationReturnType<RT extends (...args: any) => any> = ReturnType<RT> extends InstanceRequestResult<any, any, boolean, InstanceResponseStyle> ? Promise<NonNullable<Awaited<ReturnType<RT>>['data']>> : never;
+type BaseApiClientFunctions = {
+    readonly [KT in OperationsNames]: OperationsType[KT] extends Function ? (options?: Parameters<OperationsType[KT]>[0]) => OperationReturnType<OperationsType[KT]> : never;
+};
+type InstanceClientFunctions = {
+    readonly [KT in InstanceOperationsNames as InstanceOperationsType[KT] extends Function ? `preview2${Capitalize<KT>}` : never]: InstanceOperationsType[KT] extends Function ? (options?: Parameters<InstanceOperationsType[KT]>[0]) => InstanceOperationReturnType<InstanceOperationsType[KT]> : never;
+};
+type ApiClientFunctions = BaseApiClientFunctions & InstanceClientFunctions;
+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>;
+    protected _instanceClient: ReturnType<typeof createInstanceClient>;
     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;
+    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.
+     */
     get version(): string;
     /**
      * The API version for which this client was build
@@ -39,5 +71,32 @@ export declare class ApiClient extends CmsIntegrationApiClient {
      *
      * @returns The version information from the running instance
      */
-    getInstanceInfo(): CancelablePromise<InstanceApiVersionInfo>;
+    getInstanceInfo(): Promise<InstanceApiVersionInfo>;
+    getOpenApiSpec(): Promise<any>;
+    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 type ApiClientStatic = typeof ApiClient;
+export type CmsIntegrationApiClient = InstanceType<typeof ApiClient>;
+export default ApiClient;

package/dist/api-client.js

@@ -1,64 +1,159 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiClient = void 0;
-const client_1 = require("./client");
-const getaccesstoken_1 = require("./getaccesstoken");
+exports.ApiClient = exports.ApiError = void 0;
+const Operations = __importStar(require("./client/sdk.gen"));
+const client_1 = require("./client/client");
+const InstanceOperations = __importStar(require("./instance.client/sdk.gen"));
+const client_2 = require("./instance.client/client");
 const config_1 = require("./config");
 const types_1 = require("./types");
+const client_config_1 = require("./client-config");
 const version_json_1 = __importDefault(require("./version.json"));
-const OpenAPI_1 = require("./client/core/OpenAPI");
-class ApiClient extends client_1.CmsIntegrationApiClient {
-    /**
-     * Create a new instance of the API Client
-     *
-     * @param   config  The instance configuration
-     */
+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;
+    });
+    // Bind the older Preview2 operations
+    Object.getOwnPropertyNames(InstanceOperations).filter(isInstanceClientFunction).forEach(propName => {
+        async function wrapper(args) {
+            const operationArgs = {
+                throwOnError: false,
+                ...args,
+                //@ts-expect-error
+                client: this._instanceClient
+            };
+            //@ts-expect-error
+            const result = await InstanceOperations[propName](operationArgs);
+            if (result.data)
+                return result.data;
+            throw new ApiError(result);
+        }
+        const fnName = `preview2${toCapitalized(propName)}`;
+        //@ts-expect-error
+        NewClass.prototype[fnName] = wrapper;
+    });
+    // Return the new class
+    return NewClass;
+}
+function toCapitalized(toCapitalize) {
+    return (toCapitalize.substring(0, 1).toUpperCase() + toCapitalize.substring(1));
+}
+function createIsFunctionValidator(baseType) {
+    return (propName) => {
+        return typeof (baseType[propName]) == 'function';
+    };
+}
+const isApiClientFunction = createIsFunctionValidator(Operations);
+const isInstanceClientFunction = createIsFunctionValidator(InstanceOperations);
+class BaseApiClient {
+    _config;
+    _client;
+    _instanceClient;
     constructor(config) {
-        const options = config ?? (0, config_1.getCmsIntegrationApiConfigFromEnvironment)();
-        options.base = new URL(OpenAPI_1.OpenAPI.BASE, options.base);
-        if (options.cmsVersion == types_1.OptiCmsVersion.CMS12)
-            options.base.pathname = options.base.pathname.replace('preview2', 'preview1');
-        const apiVersion = options.cmsVersion == types_1.OptiCmsVersion.CMS12 ? 'preview1' : OpenAPI_1.OpenAPI.VERSION;
-        let access_token = undefined;
-        super({
-            BASE: options.base.href,
-            TOKEN: async () => {
-                if (!access_token)
-                    access_token = await (0, getaccesstoken_1.getAccessToken)(options).catch(e => {
-                        if (options.debug) {
-                            console.error(`🔴 [CMS API] Failed to obtain an access token`);
-                            console.error(e);
-                        }
-                        return undefined;
-                    });
-                return access_token ?? '';
-            },
-            HEADERS: {
-                Connection: "Close"
-            },
-            WITH_CREDENTIALS: true,
-            CREDENTIALS: "include",
-            VERSION: apiVersion
-        });
-        this._config = options;
+        // 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));
+        this._instanceClient = (0, client_2.createClient)((0, client_config_1.createClientConfig)((0, client_2.createConfig)({
+            baseUrl: new URL('/_cms/preview2', this._config.base).href
+        })));
+        // 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;
+            });
+            this._instanceClient.interceptors.request.use(async (request) => {
+                console.log(`🔍 [CMS API] Sending ${request.method} request to ${request.url}`);
+                return request;
+            });
+            this._instanceClient.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.CMS13;
+        return this._config.cmsVersion ?? types_1.OptiCmsVersion.CMSSAAS;
     }
     /**
      * The URL of the CMS instance
      */
     get cmsUrl() {
-        return this._config.base;
+        if (this._config.base)
+            return this._config.base;
+        const baseUrl = this._client.getConfig().baseUrl;
+        return baseUrl ? new URL(baseUrl) : undefined;
     }
     /**
      * Marker to indicate if the client has debugging enabled
@@ -66,8 +161,14 @@ class ApiClient extends client_1.CmsIntegrationApiClient {
     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() {
-        return this._config.cmsVersion == types_1.OptiCmsVersion.CMS12 ? 'preview1' : OpenAPI_1.OpenAPI.VERSION;
+        const baseUrl = this._client.getConfig().baseUrl;
+        const detectedVersion = baseUrl?.match(/^https{0,1}:\/\/.+?\/(_cms\/){0,1}([a-z0-9\.]+)(\/|$)/)?.at(2);
+        return detectedVersion || "";
     }
     /**
      * The API version for which this client was build
@@ -86,14 +187,73 @@ class ApiClient extends client_1.CmsIntegrationApiClient {
      *
      * @returns The version information from the running instance
      */
-    getInstanceInfo() {
-        return this.request.request({
-            method: 'GET',
-            url: '/info',
-            errors: {
-                403: `Forbidden`,
-            },
+    async getInstanceInfo() {
+        const result = await this._client.get({
+            url: '/info'
+        });
+        const instanceResult = await this._instanceClient.get({
+            url: '/info'
         });
+        if (result.data) {
+            const data = result.data;
+            data.baseUrl = this._client.getConfig().baseUrl;
+            data.results = {
+                preview2Data: {
+                    baseUrl: this._instanceClient.getConfig().baseUrl,
+                    ...instanceResult?.data ?? {}
+                },
+                ...data.results,
+            };
+            return data;
+        }
+        throw new ApiError(result);
+    }
+    async getOpenApiSpec() {
+        const result = await this._client.get({
+            url: '/docs/content-openapi.json',
+        });
+        if (result.data)
+            return result.data;
+        throw new ApiError(result);
+    }
+    getSchemaItemBase() {
+        let baseUrl = this._client.getConfig().baseUrl;
+        if (typeof (baseUrl) === 'string' && !baseUrl.endsWith('/'))
+            baseUrl = baseUrl + '/';
+        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.ApiClient = ApiClient;
+exports.ApiError = ApiError;
+exports.ApiClient = applyOperations(BaseApiClient);
+exports.default = exports.ApiClient;

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

@@ -0,0 +1,2 @@
+import type { Client, Config } from './types.gen';
+export declare const createClient: (config?: Config) => Client;

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

@@ -0,0 +1,208 @@
+"use strict";
+// This file is auto-generated by @hey-api/openapi-ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = void 0;
+const serverSentEvents_gen_1 = require("../core/serverSentEvents.gen");
+const utils_gen_1 = require("../core/utils.gen");
+const utils_gen_2 = require("./utils.gen");
+const createClient = (config = {}) => {
+    let _config = (0, utils_gen_2.mergeConfigs)((0, utils_gen_2.createConfig)(), config);
+    const getConfig = () => ({ ..._config });
+    const setConfig = (config) => {
+        _config = (0, utils_gen_2.mergeConfigs)(_config, config);
+        return getConfig();
+    };
+    const interceptors = (0, utils_gen_2.createInterceptors)();
+    const beforeRequest = async (options) => {
+        const opts = {
+            ..._config,
+            ...options,
+            fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+            headers: (0, utils_gen_2.mergeHeaders)(_config.headers, options.headers),
+            serializedBody: undefined,
+        };
+        if (opts.security) {
+            await (0, utils_gen_2.setAuthParams)({
+                ...opts,
+                security: opts.security,
+            });
+        }
+        if (opts.requestValidator) {
+            await opts.requestValidator(opts);
+        }
+        if (opts.body !== undefined && opts.bodySerializer) {
+            opts.serializedBody = opts.bodySerializer(opts.body);
+        }
+        // remove Content-Type header if body is empty to avoid sending invalid requests
+        if (opts.body === undefined || opts.serializedBody === '') {
+            opts.headers.delete('Content-Type');
+        }
+        const url = (0, utils_gen_2.buildUrl)(opts);
+        return { opts, 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;
+        let 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;
+                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 'json':
+                case 'text':
+                    data = await response[parseAs]();
+                    break;
+                case 'stream':
+                    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'
+                ? data
+                : {
+                    data,
+                    ...result,
+                };
+        }
+        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) => {
+        const { opts, url } = await beforeRequest(options);
+        return (0, serverSentEvents_gen_1.createSseClient)({
+            ...opts,
+            body: opts.body,
+            headers: opts.headers,
+            method,
+            onRequest: async (url, init) => {
+                let request = new Request(url, init);
+                for (const fn of interceptors.request.fns) {
+                    if (fn) {
+                        request = await fn(request, opts);
+                    }
+                }
+                return request;
+            },
+            url,
+        });
+    };
+    return {
+        buildUrl: utils_gen_2.buildUrl,
+        connect: makeMethodFn('CONNECT'),
+        delete: makeMethodFn('DELETE'),
+        get: makeMethodFn('GET'),
+        getConfig,
+        head: makeMethodFn('HEAD'),
+        interceptors,
+        options: makeMethodFn('OPTIONS'),
+        patch: makeMethodFn('PATCH'),
+        post: makeMethodFn('POST'),
+        put: makeMethodFn('PUT'),
+        request,
+        setConfig,
+        sse: {
+            connect: makeSseFn('CONNECT'),
+            delete: makeSseFn('DELETE'),
+            get: makeSseFn('GET'),
+            head: makeSseFn('HEAD'),
+            options: makeSseFn('OPTIONS'),
+            patch: makeSseFn('PATCH'),
+            post: makeSseFn('POST'),
+            put: makeSseFn('PUT'),
+            trace: makeSseFn('TRACE'),
+        },
+        trace: makeMethodFn('TRACE'),
+    };
+};
+exports.createClient = createClient;

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

@@ -0,0 +1,8 @@
+export type { Auth } from '../core/auth.gen';
+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 { createClient } from './client.gen';
+export type { Client, ClientOptions, Config, CreateClientConfig, Options, OptionsLegacyParser, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from './types.gen';
+export { createConfig, mergeHeaders } from './utils.gen';

package/dist/client/client/index.js

@@ -0,0 +1,17 @@
+"use strict";
+// This file is auto-generated by @hey-api/openapi-ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeHeaders = exports.createConfig = exports.createClient = exports.serializeQueryKeyValue = exports.buildClientParams = exports.urlSearchParamsBodySerializer = exports.jsonBodySerializer = exports.formDataBodySerializer = void 0;
+var bodySerializer_gen_1 = require("../core/bodySerializer.gen");
+Object.defineProperty(exports, "formDataBodySerializer", { enumerable: true, get: function () { return bodySerializer_gen_1.formDataBodySerializer; } });
+Object.defineProperty(exports, "jsonBodySerializer", { enumerable: true, get: function () { return bodySerializer_gen_1.jsonBodySerializer; } });
+Object.defineProperty(exports, "urlSearchParamsBodySerializer", { enumerable: true, get: function () { return bodySerializer_gen_1.urlSearchParamsBodySerializer; } });
+var params_gen_1 = require("../core/params.gen");
+Object.defineProperty(exports, "buildClientParams", { enumerable: true, get: function () { return params_gen_1.buildClientParams; } });
+var queryKeySerializer_gen_1 = require("../core/queryKeySerializer.gen");
+Object.defineProperty(exports, "serializeQueryKeyValue", { enumerable: true, get: function () { return queryKeySerializer_gen_1.serializeQueryKeyValue; } });
+var client_gen_1 = require("./client.gen");
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_gen_1.createClient; } });
+var utils_gen_1 = require("./utils.gen");
+Object.defineProperty(exports, "createConfig", { enumerable: true, get: function () { return utils_gen_1.createConfig; } });
+Object.defineProperty(exports, "mergeHeaders", { enumerable: true, get: function () { return utils_gen_1.mergeHeaders; } });