chore: update custom third-party client

package.json

···
   "scripts": {
     "build": "turbo run build --filter=\"!@example/openapi-ts-sample\"",
     "changeset": "changeset",
-    "client": "sh ./scripts/client.sh",
     "example": "sh ./scripts/example.sh",
     "format": "prettier --write .",
     "lint:fix": "prettier --check --write . && eslint . --fix",
···
     "@changesets/changelog-github": "0.5.0",
     "@changesets/cli": "2.27.8",
     "@config/vite-base": "workspace:*",
-    "@hey-api/client-custom": "workspace:*",
+    "@hey-api/custom-client": "workspace:*",
     "@types/node": "22.10.5",
     "@typescript-eslint/eslint-plugin": "8.29.1",
     "@vitest/coverage-v8": "3.1.1",

packages/client-custom/package.json packages/custom-client/package.json

···
 {
-  "name": "@hey-api/client-custom",
+  "name": "@hey-api/custom-client",
   "version": "0.1.1",
   "description": "Custom client for `@hey-api/openapi-ts` codegen. Used for testing.",
   "private": true,

packages/client-custom/rollup.config.mjs packages/custom-client/rollup.config.mjs

···
   defineConfig({
     external: (id) => {
       const normalizedId = id.split(path.sep).join('/');
-      if (normalizedId === '@hey-api/client-core') {
-        return false;
-      }
       return (
         !normalizedId.startsWith('/') && !/^[a-zA-Z]:\//.test(normalizedId)
       );

packages/client-custom/src/__tests__/utils.test.ts packages/custom-client/src/__tests__/utils.test.ts

···
-import type { Auth } from '@hey-api/client-core';
 import { describe, expect, it, vi } from 'vitest';
 
+import type { Auth } from '../core/auth';
 import { getParseAs, setAuthParams } from '../utils';
 
 describe('getParseAs', () => {

packages/client-custom/src/index.ts packages/custom-client/src/index.ts

···
 export { createClient } from './client';
+export type { Auth } from './core/auth';
+export type { QuerySerializerOptions } from './core/bodySerializer';
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer,
+} from './core/bodySerializer';
+export { buildClientParams } from './core/params';
 export type {
   Client,
   ClientOptions,
···
   TDataShape,
 } from './types';
 export { createConfig } from './utils';
-export type { Auth, QuerySerializerOptions } from '@hey-api/client-core';
-export {
-  buildClientParams,
-  formDataBodySerializer,
-  jsonBodySerializer,
-  urlSearchParamsBodySerializer,
-} from '@hey-api/client-core';

packages/client-custom/src/plugin.ts packages/custom-client/src/plugin.ts

···
   /**
    * Plugin name. Must be unique.
    */
-  name: '@hey-api/client-custom';
+  name: '@hey-api/custom-client';
 }
 
 export const defaultConfig: Plugin.Config<Config> = {
   ...clientDefaultConfig,
   _handler: clientPluginHandler,
   _handlerLegacy: () => {},
-  name: '@hey-api/client-custom',
+  bundle: false,
+  name: '@hey-api/custom-client',
 };
 
 /**
- * Type helper for `@hey-api/client-custom` plugin, returns {@link Plugin.Config} object
+ * Type helper for `@hey-api/custom-client` plugin, returns {@link Plugin.Config} object
  */
 export const customClientPlugin: Plugin.DefineConfig<Config> = (config) => ({
   ...defaultConfig,

packages/client-custom/src/types.ts packages/custom-client/src/types.ts

···
-import type {
-  Auth,
-  Client as CoreClient,
-  Config as CoreConfig,
-} from '@hey-api/client-core';
-
+import type { Auth } from './core/auth';
+import type { Client as CoreClient, Config as CoreConfig } from './core/types';
 import type { Middleware } from './utils';
 
 export interface Config<T extends ClientOptions = ClientOptions>

packages/client-custom/src/utils.ts packages/custom-client/src/utils.ts

···
+import { getAuthToken } from './core/auth';
 import type {
   QuerySerializer,
   QuerySerializerOptions,
-} from '@hey-api/client-core';
+} from './core/bodySerializer';
+import { jsonBodySerializer } from './core/bodySerializer';
 import {
-  getAuthToken,
-  jsonBodySerializer,
   serializeArrayParam,
   serializeObjectParam,
   serializePrimitiveParam,
-} from '@hey-api/client-core';
-
+} from './core/pathSerializer';
 import type { Client, ClientOptions, Config, RequestOptions } from './types';
 
 interface PathSerializer {

packages/custom-client/src/core/auth.ts

···
+export type AuthToken = string | undefined;
+
+export interface Auth {
+  /**
+   * Which part of the request do we use to send the auth?
+   *
+   * @default 'header'
+   */
+  in?: 'header' | 'query' | 'cookie';
+  /**
+   * Header or query parameter name.
+   *
+   * @default 'Authorization'
+   */
+  name?: string;
+  scheme?: 'basic' | 'bearer';
+  type: 'apiKey' | 'http';
+}
+
+export const getAuthToken = async (
+  auth: Auth,
+  callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken,
+): Promise<string | undefined> => {
+  const token =
+    typeof callback === 'function' ? await callback(auth) : callback;
+
+  if (!token) {
+    return;
+  }
+
+  if (auth.scheme === 'bearer') {
+    return `Bearer ${token}`;
+  }
+
+  if (auth.scheme === 'basic') {
+    return `Basic ${btoa(token)}`;
+  }
+
+  return token;
+};

packages/custom-client/src/core/bodySerializer.ts

···
+import type {
+  ArrayStyle,
+  ObjectStyle,
+  SerializerOptions,
+} from './pathSerializer';
+
+export type QuerySerializer = (query: Record<string, unknown>) => string;
+
+export type BodySerializer = (body: any) => any;
+
+export interface QuerySerializerOptions {
+  allowReserved?: boolean;
+  array?: SerializerOptions<ArrayStyle>;
+  object?: SerializerOptions<ObjectStyle>;
+}
+
+const serializeFormDataPair = (data: FormData, key: string, value: unknown) => {
+  if (typeof value === 'string' || value instanceof Blob) {
+    data.append(key, value);
+  } else {
+    data.append(key, JSON.stringify(value));
+  }
+};
+
+const serializeUrlSearchParamsPair = (
+  data: URLSearchParams,
+  key: string,
+  value: unknown,
+) => {
+  if (typeof value === 'string') {
+    data.append(key, value);
+  } else {
+    data.append(key, JSON.stringify(value));
+  }
+};
+
+export const formDataBodySerializer = {
+  bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(
+    body: T,
+  ) => {
+    const data = new FormData();
+
+    Object.entries(body).forEach(([key, value]) => {
+      if (value === undefined || value === null) {
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => serializeFormDataPair(data, key, v));
+      } else {
+        serializeFormDataPair(data, key, value);
+      }
+    });
+
+    return data;
+  },
+};
+
+export const jsonBodySerializer = {
+  bodySerializer: <T>(body: T) =>
+    JSON.stringify(body, (key, value) =>
+      typeof value === 'bigint' ? value.toString() : value,
+    ),
+};
+
+export const urlSearchParamsBodySerializer = {
+  bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(
+    body: T,
+  ) => {
+    const data = new URLSearchParams();
+
+    Object.entries(body).forEach(([key, value]) => {
+      if (value === undefined || value === null) {
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => serializeUrlSearchParamsPair(data, key, v));
+      } else {
+        serializeUrlSearchParamsPair(data, key, value);
+      }
+    });
+
+    return data.toString();
+  },
+};

packages/custom-client/src/core/params.ts

···
+type Slot = 'body' | 'headers' | 'path' | 'query';
+
+export type Field =
+  | {
+      in: Exclude<Slot, 'body'>;
+      key: string;
+      map?: string;
+    }
+  | {
+      in: Extract<Slot, 'body'>;
+      key?: string;
+      map?: string;
+    };
+
+export interface Fields {
+  allowExtra?: Partial<Record<Slot, boolean>>;
+  args?: ReadonlyArray<Field>;
+}
+
+export type FieldsConfig = ReadonlyArray<Field | Fields>;
+
+const extraPrefixesMap: Record<string, Slot> = {
+  $body_: 'body',
+  $headers_: 'headers',
+  $path_: 'path',
+  $query_: 'query',
+};
+const extraPrefixes = Object.entries(extraPrefixesMap);
+
+type KeyMap = Map<
+  string,
+  {
+    in: Slot;
+    map?: string;
+  }
+>;
+
+const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
+  if (!map) {
+    map = new Map();
+  }
+
+  for (const config of fields) {
+    if ('in' in config) {
+      if (config.key) {
+        map.set(config.key, {
+          in: config.in,
+          map: config.map,
+        });
+      }
+    } else if (config.args) {
+      buildKeyMap(config.args, map);
+    }
+  }
+
+  return map;
+};
+
+interface Params {
+  body: unknown;
+  headers: Record<string, unknown>;
+  path: Record<string, unknown>;
+  query: Record<string, unknown>;
+}
+
+const stripEmptySlots = (params: Params) => {
+  for (const [slot, value] of Object.entries(params)) {
+    if (value && typeof value === 'object' && !Object.keys(value).length) {
+      delete params[slot as Slot];
+    }
+  }
+};
+
+export const buildClientParams = (
+  args: ReadonlyArray<unknown>,
+  fields: FieldsConfig,
+) => {
+  const params: Params = {
+    body: {},
+    headers: {},
+    path: {},
+    query: {},
+  };
+
+  const map = buildKeyMap(fields);
+
+  let config: FieldsConfig[number] | undefined;
+
+  for (const [index, arg] of args.entries()) {
+    if (fields[index]) {
+      config = fields[index];
+    }
+
+    if (!config) {
+      continue;
+    }
+
+    if ('in' in config) {
+      if (config.key) {
+        const field = map.get(config.key)!;
+        const name = field.map || config.key;
+        (params[field.in] as Record<string, unknown>)[name] = arg;
+      } else {
+        params.body = arg;
+      }
+    } else {
+      for (const [key, value] of Object.entries(arg ?? {})) {
+        const field = map.get(key);
+
+        if (field) {
+          const name = field.map || key;
+          (params[field.in] as Record<string, unknown>)[name] = value;
+        } else {
+          const extra = extraPrefixes.find(([prefix]) =>
+            key.startsWith(prefix),
+          );
+
+          if (extra) {
+            const [prefix, slot] = extra;
+            (params[slot] as Record<string, unknown>)[
+              key.slice(prefix.length)
+            ] = value;
+          } else {
+            for (const [slot, allowed] of Object.entries(
+              config.allowExtra ?? {},
+            )) {
+              if (allowed) {
+                (params[slot as Slot] as Record<string, unknown>)[key] = value;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  stripEmptySlots(params);
+
+  return params;
+};

packages/custom-client/src/core/pathSerializer.ts

···
+interface SerializeOptions<T>
+  extends SerializePrimitiveOptions,
+    SerializerOptions<T> {}
+
+interface SerializePrimitiveOptions {
+  allowReserved?: boolean;
+  name: string;
+}
+
+export interface SerializerOptions<T> {
+  /**
+   * @default true
+   */
+  explode: boolean;
+  style: T;
+}
+
+export type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+export type ArraySeparatorStyle = ArrayStyle | MatrixStyle;
+type MatrixStyle = 'label' | 'matrix' | 'simple';
+export type ObjectStyle = 'form' | 'deepObject';
+type ObjectSeparatorStyle = ObjectStyle | MatrixStyle;
+
+interface SerializePrimitiveParam extends SerializePrimitiveOptions {
+  value: string;
+}
+
+export const separatorArrayExplode = (style: ArraySeparatorStyle) => {
+  switch (style) {
+    case 'label':
+      return '.';
+    case 'matrix':
+      return ';';
+    case 'simple':
+      return ',';
+    default:
+      return '&';
+  }
+};
+
+export const separatorArrayNoExplode = (style: ArraySeparatorStyle) => {
+  switch (style) {
+    case 'form':
+      return ',';
+    case 'pipeDelimited':
+      return '|';
+    case 'spaceDelimited':
+      return '%20';
+    default:
+      return ',';
+  }
+};
+
+export const separatorObjectExplode = (style: ObjectSeparatorStyle) => {
+  switch (style) {
+    case 'label':
+      return '.';
+    case 'matrix':
+      return ';';
+    case 'simple':
+      return ',';
+    default:
+      return '&';
+  }
+};
+
+export const serializeArrayParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+}: SerializeOptions<ArraySeparatorStyle> & {
+  value: unknown[];
+}) => {
+  if (!explode) {
+    const joinedValues = (
+      allowReserved ? value : value.map((v) => encodeURIComponent(v as string))
+    ).join(separatorArrayNoExplode(style));
+    switch (style) {
+      case 'label':
+        return `.${joinedValues}`;
+      case 'matrix':
+        return `;${name}=${joinedValues}`;
+      case 'simple':
+        return joinedValues;
+      default:
+        return `${name}=${joinedValues}`;
+    }
+  }
+
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value
+    .map((v) => {
+      if (style === 'label' || style === 'simple') {
+        return allowReserved ? v : encodeURIComponent(v as string);
+      }
+
+      return serializePrimitiveParam({
+        allowReserved,
+        name,
+        value: v as string,
+      });
+    })
+    .join(separator);
+  return style === 'label' || style === 'matrix'
+    ? separator + joinedValues
+    : joinedValues;
+};
+
+export const serializePrimitiveParam = ({
+  allowReserved,
+  name,
+  value,
+}: SerializePrimitiveParam) => {
+  if (value === undefined || value === null) {
+    return '';
+  }
+
+  if (typeof value === 'object') {
+    throw new Error(
+      'Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.',
+    );
+  }
+
+  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+
+export const serializeObjectParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+  valueOnly,
+}: SerializeOptions<ObjectSeparatorStyle> & {
+  value: Record<string, unknown> | Date;
+  valueOnly?: boolean;
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+  }
+
+  if (style !== 'deepObject' && !explode) {
+    let values: string[] = [];
+    Object.entries(value).forEach(([key, v]) => {
+      values = [
+        ...values,
+        key,
+        allowReserved ? (v as string) : encodeURIComponent(v as string),
+      ];
+    });
+    const joinedValues = values.join(',');
+    switch (style) {
+      case 'form':
+        return `${name}=${joinedValues}`;
+      case 'label':
+        return `.${joinedValues}`;
+      case 'matrix':
+        return `;${name}=${joinedValues}`;
+      default:
+        return joinedValues;
+    }
+  }
+
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value)
+    .map(([key, v]) =>
+      serializePrimitiveParam({
+        allowReserved,
+        name: style === 'deepObject' ? `${name}[${key}]` : key,
+        value: v as string,
+      }),
+    )
+    .join(separator);
+  return style === 'label' || style === 'matrix'
+    ? separator + joinedValues
+    : joinedValues;
+};

packages/custom-client/src/core/types.ts

···
+import type { Auth, AuthToken } from './auth';
+import type {
+  BodySerializer,
+  QuerySerializer,
+  QuerySerializerOptions,
+} from './bodySerializer';
+
+export interface Client<
+  RequestFn = never,
+  Config = unknown,
+  MethodFn = never,
+  BuildUrlFn = never,
+> {
+  /**
+   * Returns the final request URL.
+   */
+  buildUrl: BuildUrlFn;
+  connect: MethodFn;
+  delete: MethodFn;
+  get: MethodFn;
+  getConfig: () => Config;
+  head: MethodFn;
+  options: MethodFn;
+  patch: MethodFn;
+  post: MethodFn;
+  put: MethodFn;
+  request: RequestFn;
+  setConfig: (config: Config) => Config;
+  trace: MethodFn;
+}
+
+export interface Config {
+  /**
+   * Auth token or a function returning auth token. The resolved value will be
+   * added to the request payload as defined by its `security` array.
+   */
+  auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+  /**
+   * A function for serializing request body parameter. By default,
+   * {@link JSON.stringify()} will be used.
+   */
+  bodySerializer?: BodySerializer | null;
+  /**
+   * An object containing any HTTP headers that you want to pre-populate your
+   * `Headers` object with.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+   */
+  headers?:
+    | RequestInit['headers']
+    | Record<
+        string,
+        | string
+        | number
+        | boolean
+        | (string | number | boolean)[]
+        | null
+        | undefined
+        | unknown
+      >;
+  /**
+   * The request method.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+   */
+  method?:
+    | 'CONNECT'
+    | 'DELETE'
+    | 'GET'
+    | 'HEAD'
+    | 'OPTIONS'
+    | 'PATCH'
+    | 'POST'
+    | 'PUT'
+    | 'TRACE';
+  /**
+   * A function for serializing request query parameters. By default, arrays
+   * will be exploded in form style, objects will be exploded in deepObject
+   * style, and reserved characters are percent-encoded.
+   *
+   * This method will have no effect if the native `paramsSerializer()` Axios
+   * API function is used.
+   *
+   * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+   */
+  querySerializer?: QuerySerializer | QuerySerializerOptions;
+  /**
+   * A function transforming response data before it's returned. This is useful
+   * for post-processing data, e.g. converting ISO strings into Date objects.
+   */
+  responseTransformer?: (data: unknown) => Promise<unknown>;
+  /**
+   * A function validating response data. This is useful if you want to ensure
+   * the response conforms to the desired shape, so it can be safely passed to
+   * the transformers and returned to the user.
+   */
+  responseValidator?: (data: unknown) => Promise<unknown>;
+}

packages/openapi-ts-tests/package.json

···
     "@angular/platform-browser-dynamic": "19.2.0",
     "@angular/router": "19.2.0",
     "@config/vite-base": "workspace:*",
-    "@hey-api/client-custom": "workspace:*",
+    "@hey-api/custom-client": "workspace:*",
     "@hey-api/openapi-ts": "workspace:*",
     "@tanstack/angular-query-experimental": "5.73.3",
     "@tanstack/react-query": "5.73.3",

packages/openapi-ts-tests/test/clients.test.ts

···
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { customClientPlugin } from '@hey-api/client-custom/plugin';
+import { customClientPlugin } from '@hey-api/custom-client/plugin';
 import { createClient, type UserConfig } from '@hey-api/openapi-ts';
 import { describe, expect, it } from 'vitest';
 

packages/openapi-ts-tests/test/openapi-ts.config.ts

···
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import path from 'node:path';
 
-// @ts-ignore
-import { customClientPlugin } from '@hey-api/client-custom/plugin';
+// @ts-ignor
+import { customClientPlugin } from '@hey-api/custom-client/plugin';
 import { defineConfig } from '@hey-api/openapi-ts';
 
 // @ts-ignore
···
       path: path.resolve(__dirname, 'generated', 'sample'),
     },
     plugins: [
-      // customClientPlugin({
-      //   bundle: true,
-      // }),
-      myClientPlugin(),
+      customClientPlugin(),
+      // myClientPlugin(),
       {
         // baseUrl: false,
         // exportFromIndex: true,

packages/openapi-ts/src/generate/client.ts

···
     return;
   }
 
+  // copy third-party client to output
   const clientModulePath = path.normalize(require.resolve(plugin.name));
   const clientModulePathComponents = clientModulePath.split(path.sep);
   const clientDistPath = clientModulePathComponents

pnpm-lock.yaml

···
       '@config/vite-base':
         specifier: workspace:*
         version: link:packages/config-vite-base
-      '@hey-api/client-custom':
+      '@hey-api/custom-client':
         specifier: workspace:*
-        version: link:packages/client-custom
+        version: link:packages/custom-client
       '@types/node':
         specifier: 22.10.5
         version: 22.10.5
···
         specifier: 2.2.0
         version: 2.2.0(typescript@5.8.3)
 
-  packages/client-custom:
-    devDependencies:
-      '@config/vite-base':
-        specifier: workspace:*
-        version: link:../config-vite-base
-      '@hey-api/openapi-ts':
-        specifier: workspace:*
-        version: link:../openapi-ts
-
   packages/config-vite-base:
     dependencies:
       vite:
···
       typescript:
         specifier: ^5.8.3
         version: 5.8.3
+
+  packages/custom-client:
+    devDependencies:
+      '@config/vite-base':
+        specifier: workspace:*
+        version: link:../config-vite-base
+      '@hey-api/openapi-ts':
+        specifier: workspace:*
+        version: link:../openapi-ts
 
   packages/nuxt:
     dependencies:
···
       '@config/vite-base':
         specifier: workspace:*
         version: link:../config-vite-base
-      '@hey-api/client-custom':
+      '@hey-api/custom-client':
         specifier: workspace:*
-        version: link:../client-custom
+        version: link:../custom-client
       '@hey-api/openapi-ts':
         specifier: workspace:*
         version: link:../openapi-ts

scripts/client.sh

···
-#!/usr/bin/env bash
-
-pnpm --filter @hey-api/client-$1 -- $2