getricky 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ricky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,137 @@
-# Temporary Holding Version
+# Ricky TypeScript SDK
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The official TypeScript and JavaScript client for the [Ricky](https://getricky.ai) REST API: contacts, conversations, messages, templates and webhooks of one organization.
+
+- Guides and reference: <https://getricky.ai/docs/api>, also in [the API repository](https://github.com/ricardostmalo/ricky-api/tree/main/docs) as Markdown
+- Source and OpenAPI description: <https://github.com/ricardostmalo/ricky-api>
+
+Node.js 18 or later, ES modules or CommonJS, with types included. No runtime dependencies: it uses the built-in `fetch`.
+
+```bash
+npm install getricky
+```
+
+## Quick start
+
+Create a key in Ricky under **Settings → API** and keep it on your server. `new Ricky()` reads it from `RICKY_API_KEY` when you pass none.
+
+```ts
+import { Ricky } from 'getricky';
+
+const ricky = new Ricky(); // or new Ricky('rky_live_…')
+
+// The channels the organization can send from.
+const { data: channels } = await ricky.listChannels();
+const whatsapp = channels.find((channel) => channel.type === 'whatsapp');
+
+// Send an approved WhatsApp template to a phone number. Ricky finds or creates
+// the contact and its conversation, and answers with the send it queued.
+let { data: send } = await ricky.startConversation({
+  body: {
+    channel_id: whatsapp!.id,
+    phone: '+50760001234',
+    template: {
+      id: '1234567890',
+      components: [{ type: 'body', parameters: [{ type: 'text', text: 'Ana' }] }],
+    },
+  },
+  headers: { 'Idempotency-Key': 'order-10482-ready' },
+});
+
+// Follow it until the provider accepts it.
+while (send.status === 'queued') {
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+  ({ data: send } = await ricky.getSend({ path: { send_id: send.id } }));
+}
+console.log(send.status, send.failure_reason);
+```
+
+Every operation of the API is a method named after its `operationId` (`listContacts`, `sendMessage`, …). Each takes one object with the parts the operation uses, `{ path, query, body, headers }`, and resolves to the response body as the API sends it: `{ data }` for one resource and `{ data, next_cursor }` for a list. Every request and response is typed, and every schema is exported as a type (`Contact`, `Conversation`, `SendMessage`, …).
+
+## Pagination
+
+`paginate` walks every page of a list operation and yields its items; `.pages()` yields whole pages:
+
+```ts
+for await (const contact of ricky.paginate(ricky.listContacts, { query: { tag_id } })) {
+  console.log(contact.id, contact.first_name);
+}
+
+for await (const page of ricky
+  .paginate(ricky.listMessages, { path: { conversation_id } })
+  .pages()) {
+  console.log(page.data.length);
+}
+```
+
+## Errors
+
+A failed request rejects with `RickyError`, carrying the API's `code`, the HTTP `status`, the `param` that caused it when known, and the `requestId` to quote to support. A request that never got an answer rejects with `RickyConnectionError`.
+
+```ts
+import { RickyError } from 'getricky';
+
+try {
+  await ricky.sendMessage({
+    path: { conversation_id },
+    body: { type: 'text', text: 'Hola' },
+  });
+} catch (error) {
+  if (error instanceof RickyError && error.code === 'outside_messaging_window') {
+    // Send an approved template instead.
+  } else {
+    throw error;
+  }
+}
+```
+
+## Retries and idempotency
+
+Writes that accept an `Idempotency-Key` get a random one unless you pass `headers: { 'Idempotency-Key': … }`. Pass your own, derived from your data, to make a retry from your side safe too: the same key and body replay the first response instead of repeating the write.
+
+Reads, and writes that carry a key, are retried twice on connection errors, `429` and `5xx`, waiting as `Retry-After` says or backing off exponentially. Change it with `new Ricky(key, { maxRetries })`. A write the API may have applied before failing answers `request_processing` on retry: read the resource before trying again.
+
+## Webhooks
+
+`verifyWebhook` checks the `X-Ricky-Signature` and `X-Ricky-Timestamp` headers against the raw body, rejects deliveries more than five minutes old, and returns the event. With Express:
+
+```ts
+import express from 'express';
+import { verifyWebhook, WebhookVerificationError } from 'getricky';
+
+const app = express();
+
+app.post('/ricky/webhooks', express.raw({ type: 'application/json' }), (req, res) => {
+  let event;
+  try {
+    event = verifyWebhook(req.body, req.headers, process.env.RICKY_WEBHOOK_SECRET!);
+  } catch (error) {
+    if (error instanceof WebhookVerificationError) return res.sendStatus(401);
+    throw error;
+  }
+  if (event.type === 'message.received') {
+    // Queue the work; deduplicate by event.id.
+  }
+  res.sendStatus(204);
+});
+```
+
+In a framework built on the Fetch API (Next.js route handlers, Hono), pass `await request.text()` and `request.headers`.
+
+Answer within 10 seconds. Deliveries can repeat, so deduplicate by `event.id`. New event types ship without a new API version: handle the ones you know and ignore the rest.
+
+## Configuration
+
+```ts
+new Ricky('rky_live_…', {
+  baseUrl: 'https://getricky.ai/api/v1',
+  maxRetries: 2,
+  fetch: globalThis.fetch, // any fetch implementation
+});
+```
+
+Cancel a request by passing `signal` from an `AbortController` with its options.
+
+## License
+
+[MIT](LICENSE)

package/dist/cjs/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/cjs/client.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ricky = exports.DEFAULT_BASE_URL = void 0;
+const node_crypto_1 = require("node:crypto");
+const errors_js_1 = require("./errors.js");
+const index_js_1 = require("./generated/client/index.js");
+const idempotency_gen_js_1 = require("./generated/idempotency.gen.js");
+const sdk_gen_js_1 = require("./generated/sdk.gen.js");
+exports.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`.
+ */
+class Ricky extends sdk_gen_js_1.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 = (0, index_js_1.createClient)((0, index_js_1.createConfig)({
+            auth: key,
+            baseUrl: options.baseUrl ?? exports.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') &&
+                idempotency_gen_js_1.idempotentOperations.has(`${request.method} ${url}`)) {
+                request.headers.set('Idempotency-Key', (0, node_crypto_1.randomUUID)());
+            }
+            return request;
+        });
+        client.interceptors.error.use((error, response) => response ? errors_js_1.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,
+        };
+    }
+}
+exports.Ricky = Ricky;
+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 errors_js_1.RickyError || error instanceof errors_js_1.RickyConnectionError
+        ? error
+        : new errors_js_1.RickyConnectionError(error);
+}

package/dist/cjs/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/cjs/errors.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookVerificationError = exports.RickyConnectionError = exports.RickyError = void 0;
+/**
+ * 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).
+ */
+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,
+        });
+    }
+}
+exports.RickyError = RickyError;
+/** The request never got an answer: DNS, TLS, a dropped connection or an abort. */
+class RickyConnectionError extends Error {
+    name = 'RickyConnectionError';
+    constructor(cause) {
+        super(cause instanceof Error ? cause.message : 'The request to Ricky failed', { cause });
+    }
+}
+exports.RickyConnectionError = RickyConnectionError;
+/** A webhook delivery failed verification and must be rejected. */
+class WebhookVerificationError extends Error {
+    name = 'WebhookVerificationError';
+}
+exports.WebhookVerificationError = WebhookVerificationError;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/cjs/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/cjs/generated/client/client.gen.js

@@ -0,0 +1,220 @@
+"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_js_1 = require("../core/serverSentEvents.gen.js");
+const utils_gen_js_1 = require("../core/utils.gen.js");
+const utils_gen_js_2 = require("./utils.gen.js");
+const createClient = (config = {}) => {
+    let _config = (0, utils_gen_js_2.mergeConfigs)((0, utils_gen_js_2.createConfig)(), config);
+    const getConfig = () => ({ ..._config });
+    const setConfig = (config) => {
+        _config = (0, utils_gen_js_2.mergeConfigs)(_config, config);
+        return getConfig();
+    };
+    const interceptors = (0, utils_gen_js_2.createInterceptors)();
+    const beforeRequest = async (options) => {
+        const opts = {
+            ..._config,
+            ...options,
+            fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+            headers: (0, utils_gen_js_2.mergeHeaders)(_config.headers, options.headers),
+            serializedBody: undefined,
+        };
+        if (opts.security) {
+            await (0, utils_gen_js_2.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 = (0, utils_gen_js_2.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: (0, utils_gen_js_1.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'
+                    ? (0, utils_gen_js_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':
+                        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 (0, serverSentEvents_gen_js_1.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: (0, utils_gen_js_1.getValidRequestBody)(opts),
+            url,
+        });
+    };
+    const _buildUrl = (options) => (0, utils_gen_js_2.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'),
+    };
+};
+exports.createClient = createClient;

package/dist/cjs/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';