@datviet/nbp-sdk 0.0.317

package/README.md

@@ -0,0 +1,121 @@
+# @datviet/nbp-sdk
+
+TypeScript SDK cho NBP API (`https://nbp.datviet.ai`) — listings, clients, contacts, tasks, tags, agent sessions.
+
+Types sinh trực tiếp từ OpenAPI của server nên autocomplete luôn khớp API thật. Chạy được trên Bun, Node 22+, và trong trình duyệt.
+
+```bash
+npm i @datviet/nbp-sdk
+```
+
+## Xác thực
+
+Hai đường, chọn theo việc UI của bạn có nhiều người dùng riêng biệt hay không:
+
+| Đường                            | Khi nào                                                          | Audit / RBAC      |
+| -------------------------------- | ---------------------------------------------------------------- | ----------------- |
+| **API key** (`sk-…`)             | prototype, script, dashboard nội bộ, hoặc backend của bạn gọi hộ | chung một account |
+| **Đăng nhập người dùng** (OAuth) | app nhiều môi giới, mỗi người quyền khác nhau                    | theo từng người   |
+
+### API key
+
+Settings → Khoá API → Tạo khoá. Chuỗi khoá chỉ hiện một lần.
+
+Khoá gắn chết vào một workspace — không cần gửi `X-Workspace-ID`, và không đổi được phạm vi từ phía client.
+
+```ts
+import { createOpencodeClient } from "@datviet/nbp-sdk/v2/client"
+
+const nbp = createOpencodeClient({
+  baseUrl: "https://nbp.datviet.ai",
+  headers: { Authorization: `Bearer ${process.env.NBP_API_KEY}` },
+  throwOnError: true,
+})
+
+const listings = await nbp.listings.list({ limit: 20 })
+const clients = await nbp.clients.list({ limit: 20 })
+```
+
+Tham số đi **phẳng** — không bọc `query` / `body`. SDK tự xếp cái nào vào query, cái nào vào body.
+
+Hai mức quyền, chọn lúc tạo khoá:
+
+| Mức       | Làm được                    | Dùng khi                                       |
+| --------- | --------------------------- | ---------------------------------------------- |
+| Chỉ đọc   | đọc listings / clients      | khoá nằm trong app của đối tác, hoặc dashboard |
+| Đọc & ghi | thêm/sửa listings / clients | hệ thống bạn tự kiểm soát (backend của bạn)    |
+
+Khoá **không** mở được `/map/*` (dữ liệu quy hoạch bán theo lượt) — đường đó dùng Partner API.
+
+### Đăng nhập người dùng (OAuth 2.0 + PKCE)
+
+`@datviet/nbp-sdk/auth` lo PKCE, đổi code, refresh, và retry-on-401. Không tự viết lại — access token sống 1 giờ nên UI thiếu refresh chạy tốt suốt buổi demo rồi mới chết lúc khách dùng thật.
+
+```ts
+import { createNbpAuth } from "@datviet/nbp-sdk/auth"
+import { createOpencodeClient } from "@datviet/nbp-sdk/v2/client"
+
+const auth = createNbpAuth({
+  clientID: "congty-a", // Datviet cấp — backend dùng chuỗi này để phân quyền
+  redirectURI: `${location.origin}/auth/callback`,
+})
+
+const nbp = createOpencodeClient({ baseUrl: "https://nbp.datviet.ai", fetch: auth.fetch })
+
+// Nút đăng nhập
+await auth.login()
+
+// Route /auth/callback
+const params = new URLSearchParams(location.search)
+const ok = await auth.handleCallback(params.get("code")!, params.get("state") ?? undefined)
+
+// Chọn workspace rồi mọi request sau đó tự mang X-Workspace-ID
+const ws = await nbp.workspaces.list()
+auth.setWorkspace(ws.data!.data[0]!.id)
+```
+
+Ba điều bắt buộc biết:
+
+1. **`redirectURI` bị khoá theo domain**: `localhost` / `127.0.0.1` (http được), `*.datviet.ai`, `*.ankapong.com` (https), và deep link `nbp://auth/callback`. Vibe-code ở local chạy ngay; deploy lên domain khác thì **auth từ chối ở bước authorize** — không phải lỗi SDK. Cách rẻ nhất: xin một subdomain `<tên-bạn>.datviet.ai`.
+2. **Người dùng phải là member của workspace**, không thì mọi request trả 403 `Not a member of this workspace`. Mời họ qua Settings → Thành viên bằng đúng email họ đăng nhập — hệ thống tự nối lúc họ login lần đầu.
+3. **`clientID` phải do Datviet cấp.** Backend dùng nó để phân quyền bề mặt tính tiền; chuỗi tự đặt sẽ bị chặn 403 `aud_not_allowed` ở các endpoint đó.
+
+## Chạy trong trình duyệt
+
+CORS đã mở cho `*.datviet.ai`, `*.ankapong.com` và mọi `http://localhost:<port>` — vibe-code ở local là chạy được ngay. Deploy lên domain riêng thì gửi domain đó để thêm vào whitelist.
+
+⚠️ Khoá `sk-…` đặt trong frontend là **coi như đã lộ** — ai mở devtools cũng đọc được. Với web app thật:
+
+- khoá read-only, hoặc
+- proxy qua backend của bạn (khoá nằm ở server), hoặc
+- dùng JWT của người dùng qua `auth.datviet.ai`.
+
+## Ví dụ hay dùng
+
+```ts
+// Tin mới nhất, có ảnh, nhà phố dưới 10 tỷ ở Quận 2
+const res = await nbp.listings.list({
+  limit: 12,
+  sortBy: "time_created",
+  sortDirection: "desc",
+  hasPhotos: "true",
+  property_type: "house",
+  maxPrice: 10_000_000_000,
+  district: "Quận 2",
+})
+
+// Tạo tin (khoá phải là "Đọc & ghi")
+await nbp.listings.create({
+  price: 8_500_000_000,
+  tags: { category: "sale", property_type: "house", district: "Quận 2", area: 80 },
+})
+
+// Quản lý khoá API — chỉ JWT của owner/admin gọi được, khoá `sk-` bị chặn 403
+await nbp.workspaces.apiKeys.list({ id: workspaceID })
+```
+
+Tag lưu trong DB bằng **key tiếng Anh** (`"house"`), UI hiện nhãn Việt (`"Nhà phố"`) — nhớ gửi key.
+
+## Bản `v2` vs bản gốc
+
+`@datviet/nbp-sdk/v2/client` là bản đang dùng (client theo class, `nbp.listings.list()`). Export ở root (`@datviet/nbp-sdk`) là bản cũ kế thừa từ opencode, giữ cho tương thích — code mới dùng `/v2/client`.

package/auth.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Đăng nhập người dùng cho UI dựng bằng SDK — OAuth 2.0 Authorization Code + PKCE với
+ * `auth.datviet.ai`.
+ *
+ * Vì sao nằm trong SDK: không có nó thì mỗi tích hợp phải tự viết PKCE + đổi code + refresh +
+ * retry-on-401. Ba phần đầu sai thì lộ ra ngay, phần cuối thì KHÔNG — access token sống 1 giờ, nên
+ * một UI thiếu refresh chạy tốt suốt buổi demo rồi mới chết lúc khách dùng thật.
+ *
+ * Zero dependency (WebCrypto + fetch, có sẵn trên browser/Bun/Node 22+): SDK này khách cài vào app
+ * của họ, thêm dep vào đây là thêm ràng buộc version cho họ.
+ *
+ * ⚠️ `redirect_uri` bị auth server khoá theo domain: `localhost`/`127.0.0.1`, `*.datviet.ai`,
+ * `*.ankapong.com`, và deep link `nbp://auth/callback`. Domain khác ⇒ auth trả lỗi ngay ở bước
+ * authorize, KHÔNG phải lỗi của SDK. Cần domain riêng thì phải thêm vào allowlist của auth service.
+ */
+/** Nơi giữ token giữa các lần load trang. Mặc định `localStorage`, không có thì giữ trong RAM. */
+export interface AuthStorage {
+    getItem(key: string): string | null | Promise<string | null>;
+    setItem(key: string, value: string): void | Promise<void>;
+    removeItem(key: string): void | Promise<void>;
+}
+export interface AuthConfig {
+    /**
+     * clientID đăng ký với Datviet (auth server không đòi đăng ký, nhưng backend NBP dùng chuỗi này
+     * làm `aud` để phân quyền — dùng chuỗi lạ là bị chặn ở các bề mặt tính tiền).
+     */
+    clientID: string;
+    /** Phải khớp URL callback thật của app và nằm trong allowlist domain ở trên. */
+    redirectURI: string;
+    issuer?: string;
+    storage?: AuthStorage;
+    /** Workspace mặc định gắn vào mọi request (`X-Workspace-ID`). Đổi được sau bằng `setWorkspace()`. */
+    workspaceID?: string;
+    /** Gọi mỗi khi token đổi (login, refresh, logout) — để app đồng bộ UI. */
+    onTokens?: (tokens: Tokens | null) => void;
+}
+export interface Tokens {
+    access: string;
+    refresh: string;
+}
+export declare function createNbpAuth(config: AuthConfig): {
+    login: () => Promise<string>;
+    authorizeUrl: () => Promise<string>;
+    handleCallback: (code: string, returnedState?: string) => Promise<boolean>;
+    refresh: () => Promise<Tokens | null>;
+    logout: () => Promise<void>;
+    fetch: typeof fetch;
+    /** Token hiện tại (đã load từ storage) — dùng để hiện trạng thái đăng nhập. */
+    tokens: () => Promise<Tokens | null>;
+    isAuthenticated: () => Promise<boolean>;
+    /** Workspace gắn vào request sau đó. Lấy id từ `GET /workspaces`. */
+    setWorkspace: (id: string | undefined) => void;
+    workspaceID: () => string | undefined;
+};

package/auth.js

@@ -0,0 +1,213 @@
+/**
+ * Đăng nhập người dùng cho UI dựng bằng SDK — OAuth 2.0 Authorization Code + PKCE với
+ * `auth.datviet.ai`.
+ *
+ * Vì sao nằm trong SDK: không có nó thì mỗi tích hợp phải tự viết PKCE + đổi code + refresh +
+ * retry-on-401. Ba phần đầu sai thì lộ ra ngay, phần cuối thì KHÔNG — access token sống 1 giờ, nên
+ * một UI thiếu refresh chạy tốt suốt buổi demo rồi mới chết lúc khách dùng thật.
+ *
+ * Zero dependency (WebCrypto + fetch, có sẵn trên browser/Bun/Node 22+): SDK này khách cài vào app
+ * của họ, thêm dep vào đây là thêm ràng buộc version cho họ.
+ *
+ * ⚠️ `redirect_uri` bị auth server khoá theo domain: `localhost`/`127.0.0.1`, `*.datviet.ai`,
+ * `*.ankapong.com`, và deep link `nbp://auth/callback`. Domain khác ⇒ auth trả lỗi ngay ở bước
+ * authorize, KHÔNG phải lỗi của SDK. Cần domain riêng thì phải thêm vào allowlist của auth service.
+ */
+const DEFAULT_ISSUER = "https://auth.datviet.ai";
+const TOKENS_KEY = "nbp_auth_tokens";
+const PKCE_KEY = "nbp_pkce_challenge";
+function memoryStorage() {
+    const map = new Map();
+    return {
+        getItem: (k) => map.get(k) ?? null,
+        setItem: (k, v) => void map.set(k, v),
+        removeItem: (k) => void map.delete(k),
+    };
+}
+function defaultStorage() {
+    if (typeof localStorage === "undefined")
+        return memoryStorage();
+    return {
+        getItem: (k) => localStorage.getItem(k),
+        setItem: (k, v) => localStorage.setItem(k, v),
+        removeItem: (k) => localStorage.removeItem(k),
+    };
+}
+function base64url(bytes) {
+    const arr = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+    let str = "";
+    for (const b of arr)
+        str += String.fromCharCode(b);
+    return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function randomString(bytes = 32) {
+    return base64url(crypto.getRandomValues(new Uint8Array(bytes)));
+}
+async function challenge(verifier) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+    return base64url(digest);
+}
+export function createNbpAuth(config) {
+    const issuer = (config.issuer ?? DEFAULT_ISSUER).replace(/\/$/, "");
+    const storage = config.storage ?? defaultStorage();
+    const state = {
+        tokens: null,
+        loaded: false,
+        workspaceID: config.workspaceID,
+        /** Refresh đang bay — nhiều request 401 cùng lúc phải dùng CHUNG một lần refresh, không thì
+         *  refresh token bị rotate song song và các request sau cầm token đã chết. */
+        refreshing: null,
+    };
+    async function load() {
+        if (state.loaded)
+            return state.tokens;
+        const raw = await storage.getItem(TOKENS_KEY);
+        state.loaded = true;
+        if (!raw)
+            return null;
+        state.tokens = JSON.parse(raw);
+        return state.tokens;
+    }
+    async function save(tokens) {
+        state.tokens = tokens;
+        state.loaded = true;
+        if (!tokens)
+            await storage.removeItem(TOKENS_KEY);
+        if (tokens)
+            await storage.setItem(TOKENS_KEY, JSON.stringify(tokens));
+        config.onTokens?.(tokens);
+    }
+    /** URL để đưa người dùng tới trang đăng nhập. Đã lưu verifier + state vào storage. */
+    async function authorizeUrl() {
+        const verifier = randomString();
+        const csrf = randomString(16);
+        await storage.setItem(PKCE_KEY, JSON.stringify({ verifier, state: csrf }));
+        const params = new URLSearchParams({
+            client_id: config.clientID,
+            redirect_uri: config.redirectURI,
+            response_type: "code",
+            code_challenge: await challenge(verifier),
+            code_challenge_method: "S256",
+            state: csrf,
+        });
+        return `${issuer}/authorize?${params}`;
+    }
+    /** Trong browser: chuyển trang sang trang đăng nhập. Ngoài browser: trả URL để tự mở. */
+    async function login() {
+        const url = await authorizeUrl();
+        if (typeof window !== "undefined")
+            window.location.href = url;
+        return url;
+    }
+    /**
+     * Gọi ở route callback với `code` (và `state` nếu có) lấy từ query string.
+     * Trả `false` khi state không khớp hoặc đổi code thất bại — KHÔNG throw, để UI hiện lỗi tử tế.
+     */
+    async function handleCallback(code, returnedState) {
+        const raw = await storage.getItem(PKCE_KEY);
+        if (!raw)
+            return false;
+        const pkce = JSON.parse(raw);
+        await storage.removeItem(PKCE_KEY);
+        // State khớp là thứ chặn CSRF; thiếu verifier thì code cũng vô dụng.
+        if (returnedState !== undefined && returnedState !== pkce.state)
+            return false;
+        const res = await fetch(`${issuer}/token`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                grant_type: "authorization_code",
+                client_id: config.clientID,
+                redirect_uri: config.redirectURI,
+                code,
+                code_verifier: pkce.verifier,
+            }),
+        }).catch(() => null);
+        if (!res?.ok)
+            return false;
+        const json = (await res.json().catch(() => null));
+        if (!json?.access_token || !json?.refresh_token)
+            return false;
+        await save({ access: json.access_token, refresh: json.refresh_token });
+        return true;
+    }
+    async function refresh() {
+        if (state.refreshing)
+            return state.refreshing;
+        state.refreshing = (async () => {
+            const current = await load();
+            if (!current)
+                return null;
+            const res = await fetch(`${issuer}/token`, {
+                method: "POST",
+                headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                body: new URLSearchParams({
+                    grant_type: "refresh_token",
+                    client_id: config.clientID,
+                    refresh_token: current.refresh,
+                }),
+            }).catch(() => null);
+            const json = res?.ok
+                ? (await res.json().catch(() => null))
+                : null;
+            if (!json?.access_token) {
+                // Refresh chết (hết 30 ngày, bị thu hồi) ⇒ xoá sạch. Giữ lại chỉ khiến mọi request sau đó
+                // 401 im lặng mà UI vẫn tưởng đang đăng nhập.
+                await save(null);
+                return null;
+            }
+            const next = { access: json.access_token, refresh: json.refresh_token ?? current.refresh };
+            await save(next);
+            return next;
+        })().finally(() => {
+            state.refreshing = null;
+        });
+        return state.refreshing;
+    }
+    async function logout() {
+        await save(null);
+        await storage.removeItem(PKCE_KEY);
+    }
+    /**
+     * `fetch` để truyền vào `createOpencodeClient({ fetch })`: tự gắn Bearer + `X-Workspace-ID`, và
+     * 401 thì refresh RỒI THỬ LẠI ĐÚNG MỘT LẦN (thử lại vòng vo sẽ biến token chết thành bão request).
+     */
+    const authFetch = async (input, init) => {
+        const send = async (token) => {
+            const source = input instanceof Request ? input.headers : init?.headers;
+            const headers = new Headers(source);
+            if (input instanceof Request && init?.headers) {
+                new Headers(init.headers).forEach((v, k) => headers.set(k, v));
+            }
+            if (token)
+                headers.set("Authorization", `Bearer ${token}`);
+            if (state.workspaceID)
+                headers.set("X-Workspace-ID", state.workspaceID);
+            return fetch(input, { ...init, headers });
+        };
+        const current = await load();
+        const res = await send(current?.access ?? null);
+        if (res.status !== 401 || !current)
+            return res;
+        const renewed = await refresh();
+        if (!renewed)
+            return res;
+        return send(renewed.access);
+    };
+    return {
+        login,
+        authorizeUrl,
+        handleCallback,
+        refresh,
+        logout,
+        fetch: authFetch,
+        /** Token hiện tại (đã load từ storage) — dùng để hiện trạng thái đăng nhập. */
+        tokens: () => load(),
+        isAuthenticated: async () => !!(await load()),
+        /** Workspace gắn vào request sau đó. Lấy id từ `GET /workspaces`. */
+        setWorkspace: (id) => {
+            state.workspaceID = id;
+        },
+        workspaceID: () => state.workspaceID,
+    };
+}

package/client.d.ts

@@ -0,0 +1,7 @@
+export * from "./gen/types.gen.js";
+import { type Config } from "./gen/client/types.gen.js";
+import { OpencodeClient } from "./gen/sdk.gen.js";
+export { type Config as OpencodeClientConfig, OpencodeClient };
+export declare function createOpencodeClient(config?: Config & {
+    directory?: string;
+}): OpencodeClient;

package/client.js

@@ -0,0 +1,25 @@
+export * from "./gen/types.gen.js";
+import { createClient } from "./gen/client/client.gen.js";
+import { OpencodeClient } from "./gen/sdk.gen.js";
+export { OpencodeClient };
+export function createOpencodeClient(config) {
+    if (!config?.fetch) {
+        const customFetch = (req) => {
+            // @ts-ignore
+            req.timeout = false;
+            return fetch(req);
+        };
+        config = {
+            ...config,
+            fetch: customFetch,
+        };
+    }
+    if (config?.directory) {
+        config.headers = {
+            ...config.headers,
+            "x-opencode-directory": config.directory,
+        };
+    }
+    const client = createClient(config);
+    return new OpencodeClient({ client });
+}

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

@@ -0,0 +1,165 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { createSseClient } from "../core/serverSentEvents.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,
+                security: opts.security,
+            });
+        }
+        if (opts.requestValidator) {
+            await opts.requestValidator(opts);
+        }
+        if (opts.body && opts.bodySerializer) {
+            opts.serializedBody = opts.bodySerializer(opts.body);
+        }
+        // remove Content-Type header if body is empty to avoid sending invalid requests
+        if (opts.serializedBody === undefined || opts.serializedBody === "") {
+            opts.headers.delete("Content-Type");
+        }
+        const url = buildUrl(opts);
+        return { opts, url };
+    };
+    const request = async (options) => {
+        // @ts-expect-error
+        const { opts, url } = await beforeRequest(options);
+        const requestInit = {
+            redirect: "follow",
+            ...opts,
+            body: opts.serializedBody,
+        };
+        let request = new Request(url, requestInit);
+        for (const fn of interceptors.request._fns) {
+            if (fn) {
+                request = await fn(request, opts);
+            }
+        }
+        // fetch must be assigned here, otherwise it would throw the error:
+        // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+        const _fetch = opts.fetch;
+        let response = await _fetch(request);
+        for (const fn of interceptors.response._fns) {
+            if (fn) {
+                response = await fn(response, request, opts);
+            }
+        }
+        const result = {
+            request,
+            response,
+        };
+        if (response.ok) {
+            if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+                return opts.responseStyle === "data"
+                    ? {}
+                    : {
+                        data: {},
+                        ...result,
+                    };
+            }
+            const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+            let data;
+            switch (parseAs) {
+                case "arrayBuffer":
+                case "blob":
+                case "formData":
+                case "json":
+                case "text":
+                    data = await response[parseAs]();
+                    break;
+                case "stream":
+                    return opts.responseStyle === "data"
+                        ? response.body
+                        : {
+                            data: response.body,
+                            ...result,
+                        };
+            }
+            if (parseAs === "json") {
+                if (opts.responseValidator) {
+                    await opts.responseValidator(data);
+                }
+                if (opts.responseTransformer) {
+                    data = await opts.responseTransformer(data);
+                }
+            }
+            return opts.responseStyle === "data"
+                ? data
+                : {
+                    data,
+                    ...result,
+                };
+        }
+        const textError = await response.text();
+        let jsonError;
+        try {
+            jsonError = JSON.parse(textError);
+        }
+        catch {
+            // noop
+        }
+        const error = jsonError ?? textError;
+        let finalError = error;
+        for (const fn of interceptors.error._fns) {
+            if (fn) {
+                finalError = (await fn(error, response, request, opts));
+            }
+        }
+        finalError = finalError || {};
+        if (opts.throwOnError) {
+            throw finalError;
+        }
+        // TODO: we probably want to return error and improve types
+        return opts.responseStyle === "data"
+            ? undefined
+            : {
+                error: finalError,
+                ...result,
+            };
+    };
+    const makeMethod = (method) => {
+        const fn = (options) => request({ ...options, method });
+        fn.sse = async (options) => {
+            const { opts, url } = await beforeRequest(options);
+            return createSseClient({
+                ...opts,
+                body: opts.body,
+                headers: opts.headers,
+                method,
+                url,
+            });
+        };
+        return fn;
+    };
+    return {
+        buildUrl,
+        connect: makeMethod("CONNECT"),
+        delete: makeMethod("DELETE"),
+        get: makeMethod("GET"),
+        getConfig,
+        head: makeMethod("HEAD"),
+        interceptors,
+        options: makeMethod("OPTIONS"),
+        patch: makeMethod("PATCH"),
+        post: makeMethod("POST"),
+        put: makeMethod("PUT"),
+        request,
+        setConfig,
+        trace: makeMethod("TRACE"),
+    };
+};

package/gen/client/index.d.ts

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

package/gen/client/index.js

@@ -0,0 +1,5 @@
+// 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 { createClient } from "./client.gen.js";
+export { createConfig, mergeHeaders } from "./utils.gen.js";