lemma-sdk 0.2.45 → 0.3.0

package/dist/react/useRecords.js

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { normalizeError, resolvePodClient, stringifyComparable } from "./utils.js";
-export function useRecords({ client, podId, tableName, filters, sort, limit = 20, pageToken, offset, sortBy, order, params, enabled = true, autoLoad = true, }) {
+export function useRecords({ client, podId, tableName, filters, sort, limit = 20, pageToken, offset, enabled = true, autoLoad = true, }) {
     const [records, setRecords] = useState([]);
     const [total, setTotal] = useState(0);
     const [nextPageToken, setNextPageToken] = useState(null);
@@ -11,10 +11,8 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
     const isEnabled = enabled && trimmedTableName.length > 0;
     const filtersKey = stringifyComparable(filters);
     const sortKey = stringifyComparable(sort);
-    const paramsKey = stringifyComparable(params);
     const stableFilters = useMemo(() => filters, [filtersKey]);
     const stableSort = useMemo(() => sort, [sortKey]);
-    const stableParams = useMemo(() => params, [paramsKey]);
     const refresh = useCallback(async (overrides = {}, signal) => {
         if (!isEnabled) {
             setRecords([]);
@@ -34,9 +32,6 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
                 limit: overrides.limit ?? limit,
                 pageToken: overrides.pageToken ?? pageToken,
                 offset: overrides.offset ?? offset,
-                sortBy: overrides.sortBy ?? sortBy,
-                order: overrides.order ?? order,
-                params: overrides.params ?? stableParams,
             });
             if (signal?.aborted)
                 return [];
@@ -62,12 +57,9 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
         isEnabled,
         limit,
         offset,
-        order,
         pageToken,
         podId,
-        sortBy,
         stableFilters,
-        stableParams,
         stableSort,
         trimmedTableName,
     ]);
@@ -88,9 +80,6 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
                 limit: overrides.limit ?? limit,
                 pageToken: overrides.pageToken ?? nextPageToken ?? undefined,
                 offset: overrides.offset ?? (nextPageToken ? undefined : (offset ?? 0) + loadedCount),
-                sortBy: overrides.sortBy ?? sortBy,
-                order: overrides.order ?? order,
-                params: overrides.params ?? stableParams,
             });
             const moreRecords = (response.items ?? []);
             setRecords((previous) => [...previous, ...moreRecords]);
@@ -106,7 +95,7 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
         finally {
             setIsLoadingMore(false);
         }
-    }, [client, isEnabled, isLoading, isLoadingMore, limit, nextPageToken, offset, order, podId, records.length, sortBy, stableFilters, stableParams, stableSort, total, trimmedTableName]);
+    }, [client, isEnabled, isLoading, isLoadingMore, limit, nextPageToken, offset, podId, records.length, stableFilters, stableSort, total, trimmedTableName]);
     useEffect(() => {
         if (!isEnabled) {
             setRecords([]);

package/dist/react/useReferencingRecords.d.ts

@@ -1,5 +1,5 @@
 import type { LemmaClient } from "../client.js";
-import type { Table } from "../types.js";
+import type { RecordSort, Table } from "../types.js";
 /**
  * React hook for fetching records from a referencing table that point back
  * to a specific record via a foreign key.
@@ -25,8 +25,7 @@ import type { Table } from "../types.js";
  *   table: "issue_history",
  *   foreignKey: "issue_id",
  *   recordId: selectedIssueId,
- *   sortBy: "created_at",
- *   order: "desc",
+ *   sort: [{ field: "created_at", direction: "desc" }],
  * });
  * ```
  */
@@ -48,8 +47,7 @@ export interface UseReferencingRecordsOptions {
     fields?: string[];
     limit?: number;
     offset?: number;
-    sortBy?: string;
-    order?: "asc" | "desc" | string;
+    sort?: RecordSort[];
     enabled?: boolean;
     autoLoad?: boolean;
 }
@@ -63,4 +61,4 @@ export interface UseReferencingRecordsResult<TRow extends Record<string, unknown
     error: Error | null;
     refresh: () => Promise<TRow[]>;
 }
-export declare function useReferencingRecords<TRow extends Record<string, unknown> = Record<string, unknown>>({ client, podId, table, foreignKey, recordId, fields, limit, offset, sortBy, order, enabled, autoLoad, }: UseReferencingRecordsOptions): UseReferencingRecordsResult<TRow>;
+export declare function useReferencingRecords<TRow extends Record<string, unknown> = Record<string, unknown>>({ client, podId, table, foreignKey, recordId, fields, limit, offset, sort, enabled, autoLoad, }: UseReferencingRecordsOptions): UseReferencingRecordsResult<TRow>;

package/dist/react/useReferencingRecords.js

@@ -25,7 +25,7 @@ function pickDefaultFields(table, foreignKey) {
     });
     return next.slice(0, 6);
 }
-export function useReferencingRecords({ client, podId, table, foreignKey, recordId = null, fields, limit = 20, offset, sortBy, order, enabled = true, autoLoad = true, }) {
+export function useReferencingRecords({ client, podId, table, foreignKey, recordId = null, fields, limit = 20, offset, sort, enabled = true, autoLoad = true, }) {
     const [referencedTable, setReferencedTable] = useState(null);
     const [columns, setColumns] = useState([]);
     const [records, setRecords] = useState([]);
@@ -36,7 +36,9 @@ export function useReferencingRecords({ client, podId, table, foreignKey, record
     const trimmedTable = table.trim();
     const trimmedRecordId = typeof recordId === "string" ? recordId.trim() : "";
     const fieldsKey = stringifyComparable(fields);
+    const sortKey = stringifyComparable(sort);
     const stableFields = useMemo(() => fields, [fieldsKey]);
+    const stableSort = useMemo(() => sort, [sortKey]);
     const isEnabled = enabled && trimmedTable.length > 0 && trimmedRecordId.length > 0;
     const refresh = useCallback(async (signal) => {
         if (!isEnabled) {
@@ -67,8 +69,7 @@ export function useReferencingRecords({ client, podId, table, foreignKey, record
                     }],
                 limit,
                 offset,
-                sortBy,
-                order,
+                sort: stableSort,
             });
             if (signal?.aborted)
                 return [];
@@ -100,10 +101,9 @@ export function useReferencingRecords({ client, podId, table, foreignKey, record
         isEnabled,
         limit,
         offset,
-        order,
         podId,
-        sortBy,
         stableFields,
+        stableSort,
         trimmedRecordId,
         trimmedTable,
     ]);

package/dist/react/useReverseRelatedRecords.d.ts

@@ -1,5 +1,5 @@
 import type { LemmaClient } from "../client.js";
-import type { Table } from "../types.js";
+import type { RecordSort, Table } from "../types.js";
 /**
  * React hook for finding records in *other* tables that reference a given
  * record. Starts from the parent table, discovers all tables with FK
@@ -45,8 +45,7 @@ export interface UseReverseRelatedRecordsOptions {
     fields?: string[];
     limit?: number;
     offset?: number;
-    sortBy?: string;
-    order?: "asc" | "desc" | string;
+    sort?: RecordSort[];
     tablesLimit?: number;
     enabled?: boolean;
     autoLoad?: boolean;
@@ -65,4 +64,4 @@ export interface UseReverseRelatedRecordsResult<TRow extends Record<string, unkn
     error: Error | null;
     refresh: () => Promise<TRow[]>;
 }
-export declare function useReverseRelatedRecords<TRow extends Record<string, unknown> = Record<string, unknown>>({ client, podId, tableName, recordId, relation, fields, limit, offset, sortBy, order, tablesLimit, enabled, autoLoad, }: UseReverseRelatedRecordsOptions): UseReverseRelatedRecordsResult<TRow>;
+export declare function useReverseRelatedRecords<TRow extends Record<string, unknown> = Record<string, unknown>>({ client, podId, tableName, recordId, relation, fields, limit, offset, sort, tablesLimit, enabled, autoLoad, }: UseReverseRelatedRecordsOptions): UseReverseRelatedRecordsResult<TRow>;

package/dist/react/useReverseRelatedRecords.js

@@ -26,7 +26,7 @@ function pickDefaultFields(table, foreignKey) {
     });
     return next.slice(0, 6);
 }
-export function useReverseRelatedRecords({ client, podId, tableName, recordId = null, relation = null, fields, limit = 20, offset, sortBy, order, tablesLimit = 100, enabled = true, autoLoad = true, }) {
+export function useReverseRelatedRecords({ client, podId, tableName, recordId = null, relation = null, fields, limit = 20, offset, sort, tablesLimit = 100, enabled = true, autoLoad = true, }) {
     const [parentTable, setParentTable] = useState(null);
     const [relatedTable, setRelatedTable] = useState(null);
     const [parentRecord, setParentRecord] = useState(null);
@@ -42,8 +42,10 @@ export function useReverseRelatedRecords({ client, podId, tableName, recordId =
     const trimmedRecordId = typeof recordId === "string" ? recordId.trim() : "";
     const relationKey = stringifyComparable(relation);
     const fieldsKey = stringifyComparable(fields);
+    const sortKey = stringifyComparable(sort);
     const stableRelation = useMemo(() => relation, [relationKey]);
     const stableFields = useMemo(() => fields, [fieldsKey]);
+    const stableSort = useMemo(() => sort, [sortKey]);
     const isEnabled = enabled && trimmedTableName.length > 0 && trimmedRecordId.length > 0;
     const refresh = useCallback(async (signal) => {
         if (!isEnabled) {
@@ -130,8 +132,7 @@ export function useReverseRelatedRecords({ client, podId, tableName, recordId =
                     }],
                 limit,
                 offset,
-                sortBy,
-                order,
+                sort: stableSort,
             });
             if (signal?.aborted)
                 return [];
@@ -162,11 +163,10 @@ export function useReverseRelatedRecords({ client, podId, tableName, recordId =
         isEnabled,
         limit,
         offset,
-        order,
         podId,
-        sortBy,
         stableFields,
         stableRelation,
+        stableSort,
         tablesLimit,
         trimmedRecordId,
         trimmedTableName,

package/dist/run-utils.d.ts

@@ -12,4 +12,28 @@ export declare function isTerminalFlowStatus(status: unknown, options?: {
 }): boolean;
 export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
 export declare function nextBackoffDelay(attempt: number, options?: BackoffOptions): number;
+/**
+ * Statuses worth retrying with backoff. Deliberately conservative: 429 is an
+ * explicit "back off", and 502/503/504 are gateway errors where the request
+ * usually never reached the handler — so retrying is safe even for writes.
+ * 500 is excluded (it may indicate a partial side effect).
+ */
+export declare const RETRYABLE_STATUS: ReadonlySet<number>;
+/** Parse a server `Retry-After` header (delta-seconds or HTTP-date) into ms,
+ *  capped at 30s. Returns null when the header is absent or unparseable. */
+export declare function serverRetryAfterMs(retryAfter: string | null | undefined): number | null;
+/** Resolve a backoff delay, honoring a server `Retry-After` header when present. */
+export declare function retryAfterMs(retryAfter: string | null | undefined, attempt: number): number;
+/** Equal jitter: keep half the delay fixed and randomize the other half, so the
+ *  result lands in `[delay/2, delay]`. Spreads correlated retries (thundering
+ *  herd) without ever waiting longer than the computed backoff. */
+export declare function applyJitter(delayMs: number, random?: () => number): number;
+/**
+ * Single source of truth for the retry decision shared by the hand-written
+ * `HttpClient` and the generated-client adapter. Returns the number of ms to
+ * wait before retrying, or `null` when the status is non-retryable or retries
+ * are exhausted. A server-advised `Retry-After` is honored verbatim (no jitter);
+ * the computed exponential backoff gets equal jitter.
+ */
+export declare function retryDelayForStatus(status: number, attempt: number, maxRetries: number, retryAfterHeader: string | null | undefined, random?: () => number): number | null;
 export {};

package/dist/run-utils.js

@@ -50,3 +50,57 @@ export function nextBackoffDelay(attempt, options = {}) {
     const delay = Math.round(baseMs * Math.pow(factor, safeAttempt));
     return Math.min(Math.max(baseMs, delay), maxMs);
 }
+/**
+ * Statuses worth retrying with backoff. Deliberately conservative: 429 is an
+ * explicit "back off", and 502/503/504 are gateway errors where the request
+ * usually never reached the handler — so retrying is safe even for writes.
+ * 500 is excluded (it may indicate a partial side effect).
+ */
+export const RETRYABLE_STATUS = new Set([429, 502, 503, 504]);
+/** Parse a server `Retry-After` header (delta-seconds or HTTP-date) into ms,
+ *  capped at 30s. Returns null when the header is absent or unparseable. */
+export function serverRetryAfterMs(retryAfter) {
+    if (!retryAfter) {
+        return null;
+    }
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return Math.min(seconds * 1000, 30_000);
+    }
+    const dateMs = Date.parse(retryAfter);
+    if (!Number.isNaN(dateMs)) {
+        return Math.max(0, Math.min(dateMs - Date.now(), 30_000));
+    }
+    return null;
+}
+/** Resolve a backoff delay, honoring a server `Retry-After` header when present. */
+export function retryAfterMs(retryAfter, attempt) {
+    return serverRetryAfterMs(retryAfter) ?? nextBackoffDelay(attempt);
+}
+/** Equal jitter: keep half the delay fixed and randomize the other half, so the
+ *  result lands in `[delay/2, delay]`. Spreads correlated retries (thundering
+ *  herd) without ever waiting longer than the computed backoff. */
+export function applyJitter(delayMs, random = Math.random) {
+    if (!Number.isFinite(delayMs) || delayMs <= 0) {
+        return 0;
+    }
+    const half = delayMs / 2;
+    return Math.round(half + random() * half);
+}
+/**
+ * Single source of truth for the retry decision shared by the hand-written
+ * `HttpClient` and the generated-client adapter. Returns the number of ms to
+ * wait before retrying, or `null` when the status is non-retryable or retries
+ * are exhausted. A server-advised `Retry-After` is honored verbatim (no jitter);
+ * the computed exponential backoff gets equal jitter.
+ */
+export function retryDelayForStatus(status, attempt, maxRetries, retryAfterHeader, random = Math.random) {
+    if (!RETRYABLE_STATUS.has(status) || attempt >= maxRetries) {
+        return null;
+    }
+    const serverMs = serverRetryAfterMs(retryAfterHeader);
+    if (serverMs !== null) {
+        return serverMs;
+    }
+    return applyJitter(nextBackoffDelay(attempt), random);
+}

package/dist/types.d.ts

@@ -38,9 +38,6 @@ export interface ListRecordsOptions {
     limit?: number;
     pageToken?: string;
     offset?: number;
-    sortBy?: string;
-    order?: "asc" | "desc" | string;
-    params?: Record<string, string | number | boolean | undefined | null>;
 }
 export interface RunFunctionOptions {
     /** Input payload for the function */
@@ -62,17 +59,26 @@ export type Conversation = GeneratedConversationResponse & {
     model?: ConversationModel | null;
     status?: string | null;
 };
+/** Discriminator for the flat message shape (replaces the old nested content union). */
+export type MessageKind = "text" | "thinking" | "notification" | "tool_call" | "tool_return";
 export interface ConversationMessageResponse {
     id: string;
     role: string;
-    content: unknown;
+    kind: MessageKind;
+    /** Body for text / thinking / notification messages. */
+    text?: string | null;
+    /** Set on tool_call / tool_return messages. */
+    tool_name?: string | null;
+    tool_call_id?: string | null;
+    /** Inputs for a tool_call (arbitrary JSON). */
+    tool_args?: unknown;
+    /** Output for a tool_return (arbitrary JSON). */
+    tool_result?: unknown;
     created_at: string;
     conversation_id?: string;
     sequence?: number;
     agent_run_id?: string | null;
     metadata?: Record<string, unknown> | null;
-    tool_call_id?: string | null;
-    tool_name?: string | null;
 }
 export type ConversationMessage = ConversationMessageResponse;
 export type FunctionRun = FunctionRunResponse;

package/dist/version.d.ts

@@ -0,0 +1,5 @@
+export declare const SDK_VERSION = "0.3.0";
+/** Sent as `X-Lemma-Client` on every request so the backend can log which client
+ *  + version hit an endpoint (User-Agent is a forbidden header in browser fetch). */
+export declare const CLIENT_HEADER_NAME = "X-Lemma-Client";
+export declare const CLIENT_HEADER_VALUE = "lemma-sdk-ts/0.3.0";

package/dist/version.js

@@ -0,0 +1,7 @@
+// Keep SDK_VERSION in sync with package.json "version". The CI codegen/drift
+// gate (workstream A) asserts they match so this can't silently drift.
+export const SDK_VERSION = "0.3.0";
+/** Sent as `X-Lemma-Client` on every request so the backend can log which client
+ *  + version hit an endpoint (User-Agent is a forbidden header in browser fetch). */
+export const CLIENT_HEADER_NAME = "X-Lemma-Client";
+export const CLIENT_HEADER_VALUE = `lemma-sdk-ts/${SDK_VERSION}`;

package/package.json

@@ -1,7 +1,9 @@
 {
   "name": "lemma-sdk",
-  "version": "0.2.45",
+  "version": "0.3.0",
   "description": "Official TypeScript SDK for Lemma APIs, optimized around pod-scoped workflows",
+  "license": "Apache-2.0",
+  "author": "Lemma",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,9 +46,9 @@
   ],
   "scripts": {
     "generate:client": "./scripts/generate_openapi_client.sh",
-    "generate:client:hey": "LEMMA_TS_GENERATOR=hey ./scripts/generate_openapi_client.sh",
     "build": "npm run clean && tsc -p tsconfig.json && npm run build:bundle",
-    "build:bundle": "tsc -p tsconfig.bundle.json && node ./scripts/build_browser_bundle.mjs",
+    "build:bundle": "node ./scripts/build_browser_bundle.mjs",
+    "test": "npm run build:bundle && vitest run",
     "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true, maxRetries: 10, retryDelay: 100 })\"",
     "registry:build": "shadcn build ./registry.json -o ./public/r",
     "registry:check": "npm run registry:build && node ./scripts/check_registry_blocks.mjs",
@@ -65,10 +67,13 @@
     "supertokens-web-js": "^0.16.0"
   },
   "devDependencies": {
-    "@hey-api/openapi-ts": "^0.73.0",
+    "@types/node": "^24.13.2",
     "@types/react": "^19.2.14",
+    "esbuild": "^0.28.1",
+    "jsdom": "^24.1.1",
     "openapi-typescript-codegen": "^0.29.0",
     "shadcn": "^4.2.0",
-    "typescript": "^5.6.3"
+    "typescript": "^5.6.3",
+    "vitest": "^2.0.5"
   }
 }

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

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

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

@@ -1,216 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-import { createSseClient } from '../core/serverSentEvents.gen';
-import { getValidRequestBody } from '../core/utils.gen';
-import { buildUrl, createConfig, createInterceptors, getParseAs, mergeConfigs, mergeHeaders, setAuthParams, } from './utils.gen';
-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/hey_client/client/index.d.ts

@@ -1,10 +0,0 @@
-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 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/hey_client/client/index.js

@@ -1,6 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-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 { createConfig, mergeHeaders } from './utils.gen';