getricky 0.0.0-stage → 0.1.0

package/dist/cjs/generated/types.gen.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file is auto-generated by @hey-api/openapi-ts
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.d.ts

@@ -0,0 +1,7 @@
+export { DEFAULT_BASE_URL, Ricky } from './client.js';
+export type { Page, Paginator, RickyOptions } from './client.js';
+export { RickyConnectionError, RickyError, WebhookVerificationError } from './errors.js';
+export type { RickyErrorCode } from './errors.js';
+export type * from './generated/types.gen.js';
+export { verifyWebhook } from './webhooks.js';
+export type { WebhookEvent, WebhookHeaders } from './webhooks.js';

package/dist/cjs/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyWebhook = exports.WebhookVerificationError = exports.RickyError = exports.RickyConnectionError = exports.Ricky = exports.DEFAULT_BASE_URL = void 0;
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "DEFAULT_BASE_URL", { enumerable: true, get: function () { return client_js_1.DEFAULT_BASE_URL; } });
+Object.defineProperty(exports, "Ricky", { enumerable: true, get: function () { return client_js_1.Ricky; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "RickyConnectionError", { enumerable: true, get: function () { return errors_js_1.RickyConnectionError; } });
+Object.defineProperty(exports, "RickyError", { enumerable: true, get: function () { return errors_js_1.RickyError; } });
+Object.defineProperty(exports, "WebhookVerificationError", { enumerable: true, get: function () { return errors_js_1.WebhookVerificationError; } });
+var webhooks_js_1 = require("./webhooks.js");
+Object.defineProperty(exports, "verifyWebhook", { enumerable: true, get: function () { return webhooks_js_1.verifyWebhook; } });

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/webhooks.d.ts

@@ -0,0 +1,25 @@
+import type { WebhookEvent as PublishedWebhookEvent } from './generated/types.gen.js';
+/**
+ * The JSON Ricky posts to a webhook endpoint. `type` is open: new event types
+ * ship without a new API version, so handle the ones you know and ignore the
+ * rest.
+ */
+export type WebhookEvent = Omit<PublishedWebhookEvent, 'type' | 'data'> & {
+    type: PublishedWebhookEvent['type'] | (string & {});
+    data: PublishedWebhookEvent['data'] & Record<string, unknown>;
+};
+/** Request headers as `Headers`, or the plain object Node.js, Express and most frameworks give. */
+export type WebhookHeaders = Headers | Record<string, string | string[] | undefined>;
+/**
+ * Verifies a delivery and returns its event. Pass the raw request body exactly
+ * as received, before any JSON parsing.
+ *
+ * `X-Ricky-Signature` holds one `v1=<hex>` value, or several separated by
+ * commas while a signing secret is being rotated; the delivery is valid when
+ * any of them is the HMAC-SHA256 of `<X-Ricky-Timestamp>.<body>` with
+ * `secret`. Deliveries whose timestamp is more than `tolerance` seconds from
+ * now are rejected, which defeats replays.
+ *
+ * @throws {WebhookVerificationError} when the delivery must be rejected.
+ */
+export declare function verifyWebhook(payload: string | Uint8Array, headers: WebhookHeaders, secret: string, tolerance?: number): WebhookEvent;

package/dist/cjs/webhooks.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyWebhook = verifyWebhook;
+const node_crypto_1 = require("node:crypto");
+const errors_js_1 = require("./errors.js");
+/**
+ * Verifies a delivery and returns its event. Pass the raw request body exactly
+ * as received, before any JSON parsing.
+ *
+ * `X-Ricky-Signature` holds one `v1=<hex>` value, or several separated by
+ * commas while a signing secret is being rotated; the delivery is valid when
+ * any of them is the HMAC-SHA256 of `<X-Ricky-Timestamp>.<body>` with
+ * `secret`. Deliveries whose timestamp is more than `tolerance` seconds from
+ * now are rejected, which defeats replays.
+ *
+ * @throws {WebhookVerificationError} when the delivery must be rejected.
+ */
+function verifyWebhook(payload, headers, secret, tolerance = 300) {
+    if (typeof payload !== 'string' && !(payload instanceof Uint8Array)) {
+        throw new errors_js_1.WebhookVerificationError('Pass the raw request body, not parsed JSON.');
+    }
+    if (!secret)
+        throw new errors_js_1.WebhookVerificationError('The webhook signing secret is empty.');
+    const timestamp = header(headers, 'x-ricky-timestamp');
+    const signatures = header(headers, 'x-ricky-signature');
+    if (!timestamp || !signatures) {
+        throw new errors_js_1.WebhookVerificationError('Missing X-Ricky-Timestamp or X-Ricky-Signature header.');
+    }
+    if (!/^\d+$/.test(timestamp)) {
+        throw new errors_js_1.WebhookVerificationError('X-Ricky-Timestamp is not a Unix timestamp.');
+    }
+    if (Math.abs(Math.floor(Date.now() / 1000) - Number(timestamp)) > tolerance) {
+        throw new errors_js_1.WebhookVerificationError('X-Ricky-Timestamp is outside the tolerance.');
+    }
+    const body = typeof payload === 'string' ? Buffer.from(payload, 'utf8') : Buffer.from(payload);
+    const expected = Buffer.from(`v1=${(0, node_crypto_1.createHmac)('sha256', secret).update(`${timestamp}.`).update(body).digest('hex')}`);
+    const matches = signatures
+        .split(',')
+        .map((candidate) => Buffer.from(candidate.trim()))
+        .filter((candidate) => candidate.length === expected.length)
+        .some((candidate) => (0, node_crypto_1.timingSafeEqual)(candidate, expected));
+    if (!matches)
+        throw new errors_js_1.WebhookVerificationError('No signature matches this payload.');
+    try {
+        return JSON.parse(body.toString('utf8'));
+    }
+    catch {
+        throw new errors_js_1.WebhookVerificationError('The payload is not JSON.');
+    }
+}
+function header(headers, name) {
+    if (headers instanceof Headers)
+        return headers.get(name) ?? undefined;
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() === name)
+            return Array.isArray(value) ? value.join(',') : value;
+    }
+    return undefined;
+}

package/dist/esm/client.d.ts

@@ -0,0 +1,51 @@
+import { RickyApi } from './generated/sdk.gen.js';
+export declare const DEFAULT_BASE_URL = "https://getricky.ai/api/v1";
+export type RickyOptions = {
+    /** Defaults to `https://getricky.ai/api/v1`. */
+    baseUrl?: string;
+    /** A fetch implementation; defaults to the global `fetch`. */
+    fetch?: typeof fetch;
+    /** Retries after the first attempt for retryable failures. Defaults to 2. */
+    maxRetries?: number;
+};
+/** One page of a list: `next_cursor` is null on the last page. */
+export type Page<TItem> = {
+    data: TItem[];
+    next_cursor: string | null;
+};
+/** Any list operation of the client: it resolves to `{ data: [...], next_cursor }`. */
+type ListOperation = (options: any) => Promise<unknown>;
+/** The item type of a list operation. */
+type ItemOf<TList extends ListOperation> = Awaited<ReturnType<TList>> extends infer TPage ? TPage extends {
+    data: (infer TItem)[];
+} ? TItem : never : never;
+/** Items of every page, in order; `pages()` yields whole pages instead. */
+export type Paginator<TItem> = AsyncIterable<TItem> & {
+    pages(): AsyncIterable<Page<TItem>>;
+};
+/**
+ * A client for one organization's API key. Every operation in the API is a
+ * method named after its `operationId`, taking `{ path, query, body, headers }`
+ * and resolving to the response body (`{ data }` or `{ data, next_cursor }`).
+ * Failures reject with `RickyError` or `RickyConnectionError`.
+ *
+ * Writes that accept an `Idempotency-Key` get a random one unless the caller
+ * passes `headers: { 'Idempotency-Key': … }`. Reads and keyed writes are
+ * retried on connection errors, 429 and 5xx, honoring `Retry-After`.
+ */
+export declare class Ricky extends RickyApi {
+    /**
+     * @param apiKey An organization API key (`rky_live_…`); defaults to the
+     *   `RICKY_API_KEY` environment variable. Use it only from a server.
+     */
+    constructor(apiKey?: string, options?: RickyOptions);
+    /**
+     * Walks a list operation page by page, passing each `next_cursor` back as
+     * `cursor`.
+     *
+     * @example
+     * for await (const contact of ricky.paginate(ricky.listContacts, { query: { tag_id } })) { … }
+     */
+    paginate<TList extends ListOperation>(list: TList, options?: Parameters<TList>[0]): Paginator<ItemOf<TList>>;
+}
+export {};

package/dist/esm/client.js

@@ -0,0 +1,120 @@
+import { randomUUID } from 'node:crypto';
+import { RickyConnectionError, RickyError } from './errors.js';
+import { createClient, createConfig } from './generated/client/index.js';
+import { idempotentOperations } from './generated/idempotency.gen.js';
+import { RickyApi } from './generated/sdk.gen.js';
+export const DEFAULT_BASE_URL = 'https://getricky.ai/api/v1';
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
+const MAX_RETRY_AFTER_SECONDS = 60;
+/**
+ * A client for one organization's API key. Every operation in the API is a
+ * method named after its `operationId`, taking `{ path, query, body, headers }`
+ * and resolving to the response body (`{ data }` or `{ data, next_cursor }`).
+ * Failures reject with `RickyError` or `RickyConnectionError`.
+ *
+ * Writes that accept an `Idempotency-Key` get a random one unless the caller
+ * passes `headers: { 'Idempotency-Key': … }`. Reads and keyed writes are
+ * retried on connection errors, 429 and 5xx, honoring `Retry-After`.
+ */
+export class Ricky extends RickyApi {
+    /**
+     * @param apiKey An organization API key (`rky_live_…`); defaults to the
+     *   `RICKY_API_KEY` environment variable. Use it only from a server.
+     */
+    constructor(apiKey, options = {}) {
+        const key = apiKey ?? globalThis.process?.env?.RICKY_API_KEY;
+        if (!key)
+            throw new Error('Pass an API key or set RICKY_API_KEY.');
+        const client = createClient(createConfig({
+            auth: key,
+            baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+            fetch: retryingFetch(options.fetch ?? globalThis.fetch, options.maxRetries ?? 2),
+            throwOnError: true,
+        }));
+        client.interceptors.request.use((request, { url }) => {
+            if (!request.headers.has('Idempotency-Key') &&
+                idempotentOperations.has(`${request.method} ${url}`)) {
+                request.headers.set('Idempotency-Key', randomUUID());
+            }
+            return request;
+        });
+        client.interceptors.error.use((error, response) => response ? RickyError.fromResponse(response, error) : asConnectionError(error));
+        super({ client });
+    }
+    /**
+     * Walks a list operation page by page, passing each `next_cursor` back as
+     * `cursor`.
+     *
+     * @example
+     * for await (const contact of ricky.paginate(ricky.listContacts, { query: { tag_id } })) { … }
+     */
+    paginate(list, options) {
+        const initial = options;
+        const fetchPage = (cursor) => list.call(this, {
+            ...initial,
+            query: { ...initial?.query, ...(cursor === undefined ? {} : { cursor }) },
+        });
+        async function* pages() {
+            let cursor = initial?.query?.cursor;
+            do {
+                const page = await fetchPage(cursor);
+                yield page;
+                cursor = page.next_cursor ?? undefined;
+            } while (cursor !== undefined);
+        }
+        return {
+            async *[Symbol.asyncIterator]() {
+                for await (const page of pages())
+                    yield* page.data;
+            },
+            pages,
+        };
+    }
+}
+function retryingFetch(baseFetch, maxRetries) {
+    return async (input, init) => {
+        const request = new Request(input, init);
+        const retryable = request.method === 'GET' ||
+            request.method === 'HEAD' ||
+            request.headers.has('Idempotency-Key');
+        for (let attempt = 0;; attempt += 1) {
+            const last = !retryable || attempt >= maxRetries;
+            let response;
+            try {
+                response = await baseFetch(last ? request : request.clone());
+            }
+            catch (error) {
+                if (last || request.signal.aborted)
+                    throw asConnectionError(error);
+                await sleep(backoffSeconds(attempt));
+                continue;
+            }
+            if (last || !RETRYABLE_STATUSES.has(response.status))
+                return response;
+            const delay = retryAfterSeconds(response.headers.get('retry-after')) ?? backoffSeconds(attempt);
+            await response.body?.cancel();
+            await sleep(delay);
+        }
+    };
+}
+/** `Retry-After` as seconds (delta or HTTP date), capped; null when absent or invalid. */
+function retryAfterSeconds(header) {
+    if (header === null || header.trim() === '')
+        return null;
+    const seconds = /^\d+$/.test(header.trim())
+        ? Number(header.trim())
+        : (Date.parse(header) - Date.now()) / 1000;
+    return Number.isFinite(seconds) ? Math.min(Math.max(seconds, 0), MAX_RETRY_AFTER_SECONDS) : null;
+}
+/** 0.5 s, 1 s, 2 s … up to 8 s, with up to 25 % jitter below. */
+function backoffSeconds(attempt) {
+    return Math.min(0.5 * 2 ** attempt, 8) * (1 - Math.random() * 0.25);
+}
+function sleep(seconds) {
+    return new Promise((resolve) => setTimeout(resolve, seconds * 1000));
+}
+function asConnectionError(error) {
+    return error instanceof RickyError || error instanceof RickyConnectionError
+        ? error
+        : new RickyConnectionError(error);
+}

package/dist/esm/errors.d.ts

@@ -0,0 +1,35 @@
+import type { Error as ErrorBody } from './generated/types.gen.js';
+/** A stable error code from the API's catalog. New codes may appear at any time. */
+export type RickyErrorCode = ErrorBody['error']['code'] | (string & {});
+/**
+ * The API answered with an error. `code` is stable and safe to branch on;
+ * `message` is for people. `code` and `requestId` are null only when the
+ * response did not come from the API itself (a proxy page, for example).
+ */
+export declare class RickyError extends Error {
+    readonly name = "RickyError";
+    readonly status: number;
+    readonly code: RickyErrorCode | null;
+    readonly param: string | null;
+    readonly requestId: string | null;
+    readonly headers: Headers;
+    constructor(options: {
+        code: RickyErrorCode | null;
+        headers: Headers;
+        message: string;
+        param: string | null;
+        requestId: string | null;
+        status: number;
+    });
+    /** Builds the error from a non-2xx response and its body, parsed when it was JSON. */
+    static fromResponse(response: Response, body: unknown): RickyError;
+}
+/** The request never got an answer: DNS, TLS, a dropped connection or an abort. */
+export declare class RickyConnectionError extends Error {
+    readonly name = "RickyConnectionError";
+    constructor(cause: unknown);
+}
+/** A webhook delivery failed verification and must be rejected. */
+export declare class WebhookVerificationError extends Error {
+    readonly name = "WebhookVerificationError";
+}

package/dist/esm/errors.js

@@ -0,0 +1,49 @@
+/**
+ * The API answered with an error. `code` is stable and safe to branch on;
+ * `message` is for people. `code` and `requestId` are null only when the
+ * response did not come from the API itself (a proxy page, for example).
+ */
+export class RickyError extends Error {
+    name = 'RickyError';
+    status;
+    code;
+    param;
+    requestId;
+    headers;
+    constructor(options) {
+        super(options.message);
+        this.status = options.status;
+        this.code = options.code;
+        this.param = options.param;
+        this.requestId = options.requestId;
+        this.headers = options.headers;
+    }
+    /** Builds the error from a non-2xx response and its body, parsed when it was JSON. */
+    static fromResponse(response, body) {
+        const error = isRecord(body) && isRecord(body.error) ? body.error : null;
+        const text = (value) => (typeof value === 'string' ? value : null);
+        return new RickyError({
+            code: text(error?.code),
+            headers: response.headers,
+            message: text(error?.message) ??
+                `HTTP ${response.status}${typeof body === 'string' && body ? `: ${body.slice(0, 200)}` : ''}`,
+            param: text(error?.param),
+            requestId: text(error?.request_id) ?? response.headers.get('x-request-id'),
+            status: response.status,
+        });
+    }
+}
+/** The request never got an answer: DNS, TLS, a dropped connection or an abort. */
+export class RickyConnectionError extends Error {
+    name = 'RickyConnectionError';
+    constructor(cause) {
+        super(cause instanceof Error ? cause.message : 'The request to Ricky failed', { cause });
+    }
+}
+/** A webhook delivery failed verification and must be rejected. */
+export class WebhookVerificationError extends Error {
+    name = 'WebhookVerificationError';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

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

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

package/dist/esm/generated/client/client.gen.js

@@ -0,0 +1,216 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { createSseClient } from '../core/serverSentEvents.gen.js';
+import { getValidRequestBody } from '../core/utils.gen.js';
+import { buildUrl, createConfig, createInterceptors, getParseAs, mergeConfigs, mergeHeaders, setAuthParams, } from './utils.gen.js';
+export const createClient = (config = {}) => {
+    let _config = mergeConfigs(createConfig(), config);
+    const getConfig = () => ({ ..._config });
+    const setConfig = (config) => {
+        _config = mergeConfigs(_config, config);
+        return getConfig();
+    };
+    const interceptors = createInterceptors();
+    const beforeRequest = async (options) => {
+        const opts = {
+            ..._config,
+            ...options,
+            fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+            headers: mergeHeaders(_config.headers, options.headers),
+            serializedBody: undefined,
+        };
+        if (opts.security) {
+            await setAuthParams(opts);
+        }
+        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 resolvedOpts = opts;
+        const url = buildUrl(resolvedOpts);
+        return { opts: resolvedOpts, url };
+    };
+    const request = async (options) => {
+        const throwOnError = options.throwOnError ?? _config.throwOnError;
+        const responseStyle = options.responseStyle ?? _config.responseStyle;
+        let request;
+        let response;
+        try {
+            const { opts, url } = await beforeRequest(options);
+            const requestInit = {
+                redirect: 'follow',
+                ...opts,
+                body: getValidRequestBody(opts),
+            };
+            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;
+            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'
+                    ? 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':
+                        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,
+                            };
+                }
+                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
+            }
+            throw jsonError ?? textError;
+        }
+        catch (error) {
+            let finalError = error;
+            for (const fn of interceptors.error.fns) {
+                if (fn) {
+                    finalError = await fn(finalError, response, request, options);
+                }
+            }
+            finalError = finalError || {};
+            if (throwOnError) {
+                throw finalError;
+            }
+            // TODO: we probably want to return error and improve types
+            return responseStyle === 'data'
+                ? undefined
+                : {
+                    error: finalError,
+                    request,
+                    response,
+                };
+        }
+    };
+    const makeMethodFn = (method) => (options) => request({ ...options, method });
+    const makeSseFn = (method) => async (options) => {
+        const { opts, url } = await beforeRequest(options);
+        return createSseClient({
+            ...opts,
+            body: opts.body,
+            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;
+            },
+            serializedBody: getValidRequestBody(opts),
+            url,
+        });
+    };
+    const _buildUrl = (options) => buildUrl({ ..._config, ...options });
+    return {
+        buildUrl: _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'),
+    };
+};

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

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

package/dist/esm/generated/client/index.js

@@ -0,0 +1,6 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.gen.js';
+export { buildClientParams } from '../core/params.gen.js';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen.js';
+export { createClient } from './client.gen.js';
+export { createConfig, mergeHeaders } from './utils.gen.js';