@xutest1/sdk 0.1.5 → 0.1.7

package/client.js

@@ -1,11 +1,71 @@
-export * from "./gen/types.gen.js";
-export { OpencodeClient };
-export { OpencodeClient as A3codeClient };
-import { createClient } from "./gen/client/client.gen.js";
-import { OpencodeClient } from "./gen/sdk.gen.js";
-export function createOpencodeClient(config) {
-    const client = createClient(config);
-    return new OpencodeClient({ client });
+import { createClient } from "@hey-api/client-fetch";
+
+export function createA3codeClient(options) {
+    const client = createClient({
+        baseUrl: options?.baseUrl ?? "http://localhost:4096",
+    });
+
+    return {
+        session: {
+            async create(opts) {
+                return client.post({ url: "/session", body: opts?.body ?? {} });
+            },
+            async get(opts) {
+                return client.get({ url: `/session/${opts.path.id}` });
+            },
+            async list() {
+                return client.get({ url: "/session" });
+            },
+            async delete(opts) {
+                return client.delete({ url: `/session/${opts.path.id}` });
+            },
+            async prompt(opts) {
+                return client.post({ url: `/session/${opts.path.id}/message`, body: opts.body });
+            },
+            async messages(opts) {
+                return client.get({ url: `/session/${opts.path.id}/message` });
+            },
+            async abort(opts) {
+                return client.post({ url: `/session/${opts.path.id}/abort` });
+            },
+        },
+        config: {
+            async get() {
+                return client.get({ url: "/config" });
+            },
+            async update(opts) {
+                return client.patch({ url: "/config", body: opts?.body });
+            },
+            async providers() {
+                return client.get({ url: "/config/providers" });
+            },
+        },
+        event: {
+            async subscribe() {
+                return client.get({ url: "/event" });
+            },
+        },
+        file: {
+            async list(opts) {
+                return client.get({ url: "/file", query: opts?.query });
+            },
+            async read(opts) {
+                return client.get({ url: "/file/content", query: opts?.query });
+            },
+        },
+        mcp: {
+            async status() {
+                return client.get({ url: "/mcp" });
+            },
+            async refresh() {
+                return client.post({ url: "/mcp/refresh" });
+            },
+            async enable(opts) {
+                return client.post({ url: `/mcp/${opts.path.name}/enable` });
+            },
+            async disable(opts) {
+                return client.post({ url: `/mcp/${opts.path.name}/disable` });
+            },
+        },
+    };
 }
-// A3code alias
-export const createA3codeClient = createOpencodeClient;

package/index.d.ts

@@ -1,15 +1,50 @@
 export * from "./client.js";
 export * from "./server.js";
-import { createOpencodeClient } from "./client.js";
-import { createOpencodeServer } from "./server.js";
-import type { ServerOptions } from "./server.js";
-export declare function createA3code(options?: ServerOptions): Promise<{
-    client: import("./client.js").OpencodeClient;
-    server: {
-        url: string;
-        close(): void;
+
+export interface A3codeOptions {
+    port?: number;
+    config?: Record<string, any>;
+}
+
+export interface A3codeServer {
+    url: string;
+    stop(): void;
+}
+
+export interface A3codeClient {
+    session: {
+        create(opts?: { body?: Record<string, any> }): Promise<any>;
+        get(opts: { path: { id: string } }): Promise<any>;
+        list(): Promise<any>;
+        delete(opts: { path: { id: string } }): Promise<any>;
+        prompt(opts: { path: { id: string }; body: any }): Promise<any>;
+        messages(opts: { path: { id: string } }): Promise<any>;
+        abort(opts: { path: { id: string } }): Promise<any>;
     };
+    config: {
+        get(): Promise<any>;
+        update(opts?: { body?: Record<string, any> }): Promise<any>;
+        providers(): Promise<any>;
+    };
+    event: {
+        subscribe(): Promise<any>;
+    };
+    file: {
+        list(opts?: { query?: Record<string, any> }): Promise<any>;
+        read(opts?: { query?: Record<string, any> }): Promise<any>;
+    };
+    mcp: {
+        status(): Promise<any>;
+        refresh(): Promise<any>;
+        enable(opts: { path: { name: string } }): Promise<any>;
+        disable(opts: { path: { name: string } }): Promise<any>;
+    };
+}
+
+export function createA3code(options?: A3codeOptions): Promise<{
+    client: A3codeClient;
+    server: A3codeServer;
 }>;
-export declare const createOpencode: typeof createA3code;
-export { createOpencodeClient as createA3codeClient };
-export { createOpencodeServer as createA3codeServer };
+
+export function createA3codeClient(options?: { baseUrl?: string }): A3codeClient;
+export function createA3CodeServer(options?: A3codeOptions): Promise<A3codeServer>;

package/index.js

@@ -1,13 +1,18 @@
 export * from "./client.js";
 export * from "./server.js";
-import { createOpencodeClient } from "./client.js";
-import { createOpencodeServer } from "./server.js";
-// Main function - spawns server + creates client
+import { createA3codeClient } from "./client.js";
+import { createA3CodeServer } from "./server.js";
+
+/**
+ * Create an A3CODE instance with server and client
+ * @param {Object} options - Configuration options
+ * @param {number} [options.port] - Port number (default: random available port)
+ * @param {Object} [options.config] - A3CODE configuration
+ * @returns {Promise<{client: Object, server: Object}>}
+ */
 export async function createA3code(options) {
-    const server = await createOpencodeServer({
-        ...options,
-    });
-    const client = createOpencodeClient({
+    const server = await createA3CodeServer(options);
+    const client = createA3codeClient({
         baseUrl: server.url,
     });
     return {
@@ -15,8 +20,3 @@ export async function createA3code(options) {
         server,
     };
 }
-// Alias for backward compatibility
-export const createOpencode = createA3code;
-// Re-export with A3code naming
-export { createOpencodeClient as createA3codeClient };
-export { createOpencodeServer as createA3codeServer };

package/package.json

@@ -1,16 +1,33 @@
 {
   "name": "@xutest1/sdk",
-  "version": "0.1.5",
-  "description": "Type-safe SDK for A3Code AI coding agent",
-  "author": "A3Code",
-  "license": "MIT",
-  "keywords": ["a3code", "ai", "sdk", "coding", "agent", "vllm"],
-  "type": "module",
+  "version": "0.1.7",
+  "description": "A3CODE SDK - AI coding assistant SDK",
+  "main": "index.js",
+  "types": "index.d.ts",
   "exports": {
-    ".": {"import": "./index.js", "types": "./index.d.ts"},
-    "./client": {"import": "./client.js", "types": "./client.d.ts"},
-    "./server": {"import": "./server.js", "types": "./server.d.ts"}
+    ".": {
+      "import": "./index.js",
+      "require": "./index.cjs",
+      "types": "./index.d.ts"
+    }
+  },
+  "files": [
+    "*.js",
+    "*.cjs",
+    "*.d.ts"
+  ],
+  "keywords": ["a3code", "ai", "sdk", "coding", "assistant"],
+  "author": "A3CODE",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/a3code/sdk"
   },
-  "main": "./index.js",
-  "types": "./index.d.ts"
+  "optionalDependencies": {
+    "@xutest1/darwin-arm64": "0.1.7",
+    "@xutest1/darwin-x64": "0.1.7",
+    "@xutest1/linux-arm64": "0.1.7",
+    "@xutest1/linux-x64": "0.1.7",
+    "@xutest1/windows-x64": "0.1.7"
+  }
 }

package/server.js

@@ -3,20 +3,17 @@ import { existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { platform, arch } from "node:os";
-// ES module equivalent of __dirname
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-/**
- * Find the ae3code binary - checks node_modules first, then falls back to PATH
- */
+
 function findBinary() {
     const os = platform();
     const cpu = arch();
-    // Map Node.js platform/arch to package names
     const platformMap = {
         darwin: "darwin",
         linux: "linux",
-        win32: "win32",
+        win32: "windows",
     };
     const archMap = {
         arm64: "arm64",
@@ -25,13 +22,10 @@ function findBinary() {
     const pkgPlatform = platformMap[os];
     const pkgArch = archMap[cpu];
     if (pkgPlatform && pkgArch) {
-        // Try to find in node_modules/@xutest1/{platform}-{arch}/bin/ae3code
         const binaryName = os === "win32" ? "ae3code.exe" : "ae3code";
         const possiblePaths = [
-            // Relative to cwd
             join(process.cwd(), "node_modules", "@xutest1", `${pkgPlatform}-${pkgArch}`, "bin", binaryName),
-            // Relative to this file (for when SDK is in node_modules)
-            join(__dirname, "..", `@xutest1`, `${pkgPlatform}-${pkgArch}`, "bin", binaryName),
+            join(__dirname, "..", `${pkgPlatform}-${pkgArch}`, "bin", binaryName),
         ];
         for (const binPath of possiblePaths) {
             if (existsSync(binPath)) {
@@ -39,15 +33,16 @@ function findBinary() {
             }
         }
     }
-    // Fall back to PATH
     return "ae3code";
 }
-export async function createOpencodeServer(options) {
+
+export async function createA3CodeServer(options) {
     options = Object.assign({
         hostname: "127.0.0.1",
-        port: 4096,
-        timeout: 5000,
+        port: 0,
+        timeout: 10000,
     }, options ?? {});
+
     const binaryPath = findBinary();
     const proc = spawn(binaryPath, [`serve`, `--hostname=${options.hostname}`, `--port=${options.port}`], {
         signal: options.signal,
@@ -56,6 +51,7 @@ export async function createOpencodeServer(options) {
             AE3CODE_CONFIG_CONTENT: JSON.stringify(options.config ?? {}),
         },
     });
+
     const url = await new Promise((resolve, reject) => {
         const id = setTimeout(() => {
             reject(new Error(`Timeout waiting for server to start after ${options.timeout}ms`));
@@ -65,10 +61,10 @@ export async function createOpencodeServer(options) {
             output += chunk.toString();
             const lines = output.split("\n");
             for (const line of lines) {
-                if (line.startsWith("opencode server listening") || line.startsWith("ae3code server listening")) {
+                if (line.includes("server listening")) {
                     const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
                     if (!match) {
-                        throw new Error(`Failed to parse server url from output: ${line}`);
+                        continue;
                     }
                     clearTimeout(id);
                     resolve(match[1]);
@@ -98,38 +94,10 @@ export async function createOpencodeServer(options) {
             });
         }
     });
+
     return {
         url,
-        close() {
-            proc.kill();
-        },
-    };
-}
-export function createOpencodeTui(options) {
-    const args = [];
-    if (options?.project) {
-        args.push(`--project=${options.project}`);
-    }
-    if (options?.model) {
-        args.push(`--model=${options.model}`);
-    }
-    if (options?.session) {
-        args.push(`--session=${options.session}`);
-    }
-    if (options?.agent) {
-        args.push(`--agent=${options.agent}`);
-    }
-    const binaryPath = findBinary();
-    const proc = spawn(binaryPath, args, {
-        signal: options?.signal,
-        stdio: "inherit",
-        env: {
-            ...process.env,
-            AE3CODE_CONFIG_CONTENT: JSON.stringify(options?.config ?? {}),
-        },
-    });
-    return {
-        close() {
+        stop() {
             proc.kill();
         },
     };

package/client.d.ts

@@ -1,8 +0,0 @@
-export * from "./gen/types.gen.js";
-export { type Config as OpencodeClientConfig, OpencodeClient };
-export { type Config as A3codeClientConfig };
-export { OpencodeClient as A3codeClient };
-import { type Config } from "./gen/client/types.gen.js";
-import { OpencodeClient } from "./gen/sdk.gen.js";
-export declare function createOpencodeClient(config?: Config): OpencodeClient;
-export declare const createA3codeClient: typeof createOpencodeClient;

package/gen/client/client.gen.d.ts

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

package/gen/client/client.gen.js

@@ -1,167 +0,0 @@
-// 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

@@ -1,7 +0,0 @@
-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

@@ -1,5 +0,0 @@
-// 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";

package/gen/client/types.gen.d.ts

@@ -1,127 +0,0 @@
-import type { Auth } from "../core/auth.gen.js";
-import type { ServerSentEventsOptions, ServerSentEventsResult } from "../core/serverSentEvents.gen.js";
-import type { Client as CoreClient, Config as CoreConfig } from "../core/types.gen.js";
-import type { Middleware } from "./utils.gen.js";
-export type ResponseStyle = "data" | "fields";
-export interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, "body" | "headers" | "method">, CoreConfig {
-    /**
-     * Base URL for all requests made by this client.
-     */
-    baseUrl?: T["baseUrl"];
-    /**
-     * Fetch API implementation. You can use this option to provide a custom
-     * fetch instance.
-     *
-     * @default globalThis.fetch
-     */
-    fetch?: (request: Request) => ReturnType<typeof fetch>;
-    /**
-     * Please don't use the Fetch client for Next.js applications. The `next`
-     * options won't have any effect.
-     *
-     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
-     */
-    next?: never;
-    /**
-     * Return the response data parsed in a specified format. By default, `auto`
-     * will infer the appropriate method from the `Content-Type` response header.
-     * You can override this behavior with any of the {@link Body} methods.
-     * Select `stream` if you don't want to parse response data at all.
-     *
-     * @default 'auto'
-     */
-    parseAs?: "arrayBuffer" | "auto" | "blob" | "formData" | "json" | "stream" | "text";
-    /**
-     * Should we return only data or multiple fields (data, error, response, etc.)?
-     *
-     * @default 'fields'
-     */
-    responseStyle?: ResponseStyle;
-    /**
-     * Throw an error instead of returning it in the response?
-     *
-     * @default false
-     */
-    throwOnError?: T["throwOnError"];
-}
-export interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = "fields", ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
-    responseStyle: TResponseStyle;
-    throwOnError: ThrowOnError;
-}>, Pick<ServerSentEventsOptions<TData>, "onSseError" | "onSseEvent" | "sseDefaultRetryDelay" | "sseMaxRetryAttempts" | "sseMaxRetryDelay"> {
-    /**
-     * Any body that you want to add to your request.
-     *
-     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
-     */
-    body?: unknown;
-    path?: Record<string, unknown>;
-    query?: Record<string, unknown>;
-    /**
-     * Security mechanism(s) to use for the request.
-     */
-    security?: ReadonlyArray<Auth>;
-    url: Url;
-}
-export interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = "fields", ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
-    serializedBody?: string;
-}
-export type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = "fields"> = ThrowOnError extends true ? Promise<TResponseStyle extends "data" ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
-    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
-    request: Request;
-    response: Response;
-}> : Promise<TResponseStyle extends "data" ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
-    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
-    error: undefined;
-} | {
-    data: undefined;
-    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
-}) & {
-    request: Request;
-    response: Response;
-}>;
-export interface ClientOptions {
-    baseUrl?: string;
-    responseStyle?: ResponseStyle;
-    throwOnError?: boolean;
-}
-type MethodFnBase = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-type MethodFnServerSentEvents = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">) => Promise<ServerSentEventsResult<TData, TError>>;
-type MethodFn = MethodFnBase & {
-    sse: MethodFnServerSentEvents;
-};
-type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = "fields">(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method"> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, "method">) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-type BuildUrlFn = <TData extends {
-    body?: unknown;
-    path?: Record<string, unknown>;
-    query?: Record<string, unknown>;
-    url: string;
-}>(options: Pick<TData, "url"> & Options<TData>) => string;
-export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn> & {
-    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
-};
-/**
- * The `createClientConfig()` function will be called on client initialization
- * and the returned object will become the client's initial configuration.
- *
- * You may want to initialize your client this way instead of calling
- * `setConfig()`. This is useful for example if you're using Next.js
- * to ensure your client always has the correct values.
- */
-export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
-export interface TDataShape {
-    body?: unknown;
-    headers?: unknown;
-    path?: unknown;
-    query?: unknown;
-    url: string;
-}
-type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
-export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = "fields"> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, "body" | "path" | "query" | "url"> & Omit<TData, "url">;
-export type OptionsLegacyParser<TData = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = "fields"> = TData extends {
-    body?: any;
-} ? TData extends {
-    headers?: any;
-} ? OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "body" | "headers" | "url"> & TData : OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "body" | "url"> & TData & Pick<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "headers"> : TData extends {
-    headers?: any;
-} ? OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "headers" | "url"> & TData & Pick<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "body"> : OmitKeys<RequestOptions<unknown, TResponseStyle, ThrowOnError>, "url"> & TData;
-export {};

package/gen/client/types.gen.js

@@ -1,2 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-export {};