@cushin/api-runtime 2.0.1

package/README.md

@@ -0,0 +1,95 @@
+# @cushin/api-runtime
+
+Runtime utilities for Cushin API codegen - provides type-safe HTTP client and schema helpers that can be used in both browser and Node.js environments.
+
+## Features
+
+- 🌐 **Browser-compatible** - No Node.js dependencies, works in any JavaScript environment
+- 🔐 **Built-in auth** - Token management with automatic refresh
+- 📝 **Type-safe** - Full TypeScript support with Zod schema validation
+- 🎯 **Lightweight** - Minimal bundle size, only depends on `ky` and `zod`
+
+## Installation
+
+```bash
+npm install @cushin/api-runtime ky zod
+```
+
+## Usage
+
+### Define your API configuration
+
+```typescript
+import { defineConfig, defineEndpoint } from "@cushin/api-runtime";
+import { z } from "zod";
+
+export const apiConfig = defineConfig({
+  baseUrl: "https://api.example.com",
+  endpoints: {
+    getUser: defineEndpoint({
+      path: "/users/:id",
+      method: "GET",
+      params: z.object({ id: z.string() }),
+      response: z.object({
+        id: z.string(),
+        name: z.string(),
+        email: z.string(),
+      }),
+    }),
+  },
+});
+```
+
+### Create API client
+
+```typescript
+import { createAPIClient } from "@cushin/api-runtime";
+import { apiConfig } from "./api-config";
+
+const client = createAPIClient(apiConfig, {
+  getTokens: async () => ({
+    accessToken: localStorage.getItem("token") || "",
+  }),
+  onAuthError: () => {
+    // Redirect to login
+  },
+  onRefreshToken: async () => {
+    // Refresh your token
+  },
+});
+
+// Use the client
+const user = await client.getUser({ id: "123" });
+```
+
+## Key Components
+
+### `createAPIClient(config, authCallbacks?)`
+
+Creates a type-safe API client with automatic token injection and refresh.
+
+### `defineConfig(config)`
+
+Helper function to define your API configuration with type inference.
+
+### `defineEndpoint(config)`
+
+Helper function to define individual endpoints with full type safety.
+
+## Why separate from @cushin/api-codegen?
+
+The runtime code needs to be imported by your web application, while the code generation tools (`@cushin/api-codegen`) contain Node.js-specific code (file system, path manipulation, etc.) that cannot be bundled for the browser.
+
+By separating the runtime into its own package:
+- ✅ Your web app can import runtime code without bundling Node.js dependencies
+- ✅ Smaller bundle size for your application
+- ✅ Clear separation of concerns
+
+## Related Packages
+
+- **[@cushin/api-codegen](../api-codegen)** - CLI tool to generate type-safe API clients
+- **[@cushin/codegen-cli](../cli)** - Shared CLI utilities
+
+## License
+
+MIT

package/dist/chunk-GL2GG37G.js

@@ -0,0 +1,17 @@
+// src/schema.ts
+function defineConfig(config) {
+  return config;
+}
+function defineEndpoint(config) {
+  return config;
+}
+function defineEndpoints(endpoints) {
+  return endpoints;
+}
+
+export {
+  defineConfig,
+  defineEndpoint,
+  defineEndpoints
+};
+//# sourceMappingURL=chunk-GL2GG37G.js.map

package/dist/chunk-GL2GG37G.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts"],"sourcesContent":["import type { z } from \"zod\";\n\nexport type HTTPMethod = \"GET\" | \"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\";\n\nexport interface APIEndpoint {\n  path: string;\n  method: HTTPMethod;\n  baseUrl?: string;\n  params?: z.ZodType<any>;\n  query?: z.ZodType<any>;\n  body?: z.ZodType<any>;\n  response: z.ZodType<any>;\n  tags?: string[];\n  description?: string;\n}\n\nexport interface APIConfig {\n  baseUrl?: string;\n  endpoints: Record<string, APIEndpoint>;\n}\n\nexport type EndpointConfig<\n  TPath extends string = string,\n  TMethod extends HTTPMethod = HTTPMethod,\n  TParams = undefined,\n  TQuery = undefined,\n  TBody = undefined,\n  TResponse = any,\n> = {\n  path: TPath;\n  method: TMethod;\n  baseUrl?: string;\n  params?: z.ZodType<TParams>;\n  query?: z.ZodType<TQuery>;\n  body?: z.ZodType<TBody>;\n  response: z.ZodType<TResponse>;\n  tags?: string[];\n  description?: string;\n};\n\n/**\n * Helper function to define API configuration with type safety\n */\nexport function defineConfig<T extends APIConfig>(config: T): T {\n  return config;\n}\n\n/**\n * Helper function to define a single endpoint with type inference\n */\nexport function defineEndpoint<\n  TPath extends string,\n  TMethod extends HTTPMethod,\n  TParams = undefined,\n  TQuery = undefined,\n  TBody = undefined,\n  TResponse = any,\n>(\n  config: EndpointConfig<TPath, TMethod, TParams, TQuery, TBody, TResponse>,\n): EndpointConfig<TPath, TMethod, TParams, TQuery, TBody, TResponse> {\n  return config;\n}\n\n/**\n * Helper to define multiple endpoints\n */\nexport function defineEndpoints<T extends Record<string, APIEndpoint>>(\n  endpoints: T,\n): T {\n  return endpoints;\n}\n"],"mappings":";AA2CO,SAAS,aAAkC,QAAc;AAC9D,SAAO;AACT;AAKO,SAAS,eAQd,QACmE;AACnE,SAAO;AACT;AAKO,SAAS,gBACd,WACG;AACH,SAAO;AACT;","names":[]}

package/dist/chunk-RJFROHWK.js

@@ -0,0 +1,263 @@
+// src/client.ts
+import ky, { HTTPError } from "ky";
+var APIError = class extends Error {
+  constructor(message, status, response) {
+    super(message);
+    this.status = status;
+    this.response = response;
+    this.name = "APIError";
+  }
+};
+var AuthError = class extends APIError {
+  constructor(message = "Authentication failed") {
+    super(message, 401);
+    this.name = "AuthError";
+  }
+};
+var APIClient = class {
+  constructor(config, authCallbacks) {
+    this.config = config;
+    this.authCallbacks = authCallbacks;
+    this.hooks = {
+      beforeRequest: [
+        async (request) => {
+          const tokens = await this.authCallbacks?.getTokens();
+          if (tokens?.accessToken) {
+            request.headers.set(
+              "Authorization",
+              `Bearer ${tokens.accessToken}`
+            );
+          }
+        }
+      ],
+      beforeRetry: [
+        async ({ request, error, retryCount }) => {
+          if (error instanceof HTTPError && error.response.status === 401) {
+            if (retryCount === 1 && this.authCallbacks) {
+              try {
+                await this.refreshTokens();
+                const tokens = await this.authCallbacks.getTokens();
+                if (tokens?.accessToken) {
+                  request.headers.set(
+                    "Authorization",
+                    `Bearer ${tokens.accessToken}`
+                  );
+                }
+              } catch (refreshError) {
+                this.authCallbacks.onAuthError?.();
+                throw new AuthError();
+              }
+            } else {
+              this.authCallbacks?.onAuthError?.();
+              throw new AuthError();
+            }
+          }
+        }
+      ],
+      beforeError: [
+        async (error) => {
+          const { response } = error;
+          if (response?.body) {
+            try {
+              const body = await response.json();
+              error.message = body.message || `HTTP ${response.status}`;
+            } catch {
+            }
+          }
+          return error;
+        }
+      ]
+    };
+    this.client = ky.create({
+      prefixUrl: this.config.baseUrl,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      retry: {
+        limit: 2,
+        methods: ["get", "post", "put", "delete", "patch"],
+        statusCodes: [401]
+      },
+      hooks: this.hooks
+    });
+  }
+  client;
+  isRefreshing = false;
+  refreshPromise = null;
+  hooks;
+  async refreshTokens() {
+    if (!this.authCallbacks) {
+      throw new AuthError("No auth callbacks provided");
+    }
+    if (this.isRefreshing && this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.isRefreshing = true;
+    this.refreshPromise = (async () => {
+      try {
+        if (this.authCallbacks?.onRefreshToken) {
+          await this.authCallbacks.onRefreshToken();
+        } else {
+          throw new AuthError("No refresh token handler provided");
+        }
+      } catch (error) {
+        throw error;
+      } finally {
+        this.isRefreshing = false;
+        this.refreshPromise = null;
+      }
+    })();
+    return this.refreshPromise;
+  }
+  buildPath(path, params) {
+    if (!params) return path;
+    let finalPath = path;
+    Object.entries(params).forEach(([key, value]) => {
+      finalPath = finalPath.replace(
+        `:${key}`,
+        encodeURIComponent(String(value))
+      );
+    });
+    return finalPath;
+  }
+  getEndpointBaseUrl(endpoint) {
+    return endpoint.baseUrl || this.config.baseUrl;
+  }
+  getClientForEndpoint(endpoint) {
+    const endpointBaseUrl = this.getEndpointBaseUrl(endpoint);
+    if (endpointBaseUrl === this.config.baseUrl) {
+      return this.client;
+    }
+    return ky.create({
+      prefixUrl: endpointBaseUrl,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      retry: {
+        limit: 2,
+        methods: ["get", "post", "put", "delete", "patch"],
+        statusCodes: [401]
+      },
+      hooks: this.hooks
+    });
+  }
+  async request(endpoint, params, query, body) {
+    try {
+      const path = this.buildPath(endpoint.path, params);
+      const client = this.getClientForEndpoint(endpoint);
+      const options = {
+        method: endpoint.method
+      };
+      if (query && Object.keys(query).length > 0) {
+        const searchParams = new URLSearchParams();
+        Object.entries(query).forEach(([key, value]) => {
+          if (value !== void 0 && value !== null) {
+            searchParams.append(key, String(value));
+          }
+        });
+        if (searchParams.toString()) {
+          options.searchParams = searchParams;
+        }
+      }
+      if (body && endpoint.method !== "GET") {
+        if (endpoint.body) {
+          const validatedBody = endpoint.body.parse(body);
+          options.json = validatedBody;
+        } else {
+          options.json = body;
+        }
+      }
+      const response = await client(path, options);
+      const data = await response.json();
+      if (endpoint.response) {
+        return endpoint.response.parse(data);
+      }
+      return data;
+    } catch (error) {
+      if (error instanceof HTTPError) {
+        const errorData = await error.response.json().catch(() => ({}));
+        throw new APIError(
+          errorData.message || error.message,
+          error.response.status,
+          errorData
+        );
+      }
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw new APIError(
+        error instanceof Error ? error.message : "Network error",
+        0
+      );
+    }
+  }
+  updateAuthCallbacks(authCallbacks) {
+    this.authCallbacks = authCallbacks;
+  }
+  async refreshAuth() {
+    if (!this.authCallbacks) {
+      throw new AuthError("No auth callbacks provided");
+    }
+    await this.refreshTokens();
+  }
+  generateMethods() {
+    const methods = {};
+    Object.entries(this.config.endpoints).forEach(([name, endpoint]) => {
+      if (endpoint.method === "GET") {
+        if (endpoint.params && endpoint.query) {
+          methods[name] = (params, query) => {
+            return this.request(endpoint, params, query);
+          };
+        } else if (endpoint.params) {
+          methods[name] = (params) => {
+            return this.request(endpoint, params);
+          };
+        } else if (endpoint.query) {
+          methods[name] = (query) => {
+            return this.request(endpoint, void 0, query);
+          };
+        } else {
+          methods[name] = () => {
+            return this.request(endpoint);
+          };
+        }
+      } else {
+        if (endpoint.params && endpoint.body) {
+          methods[name] = (params, body) => {
+            return this.request(endpoint, params, void 0, body);
+          };
+        } else if (endpoint.params) {
+          methods[name] = (params) => {
+            return this.request(endpoint, params);
+          };
+        } else if (endpoint.body) {
+          methods[name] = (body) => {
+            return this.request(endpoint, void 0, void 0, body);
+          };
+        } else {
+          methods[name] = () => {
+            return this.request(endpoint);
+          };
+        }
+      }
+    });
+    return methods;
+  }
+};
+function createAPIClient(config, authCallbacks) {
+  const instance = new APIClient(config, authCallbacks);
+  const methods = instance.generateMethods();
+  return {
+    ...methods,
+    refreshAuth: () => instance.refreshAuth(),
+    updateAuthCallbacks: (newCallbacks) => instance.updateAuthCallbacks(newCallbacks)
+  };
+}
+
+export {
+  APIError,
+  AuthError,
+  APIClient,
+  createAPIClient
+};
+//# sourceMappingURL=chunk-RJFROHWK.js.map

package/dist/chunk-RJFROHWK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"sourcesContent":["import ky, { HTTPError } from \"ky\";\nimport type { APIConfig, APIEndpoint } from \"./schema.js\";\n\nexport interface AuthTokens {\n  accessToken: string;\n  refreshToken?: string;\n}\n\nexport interface AuthCallbacks {\n  getTokens: () => Promise<AuthTokens | null>;\n  onAuthError?: () => void;\n  onRefreshToken?: () => Promise<void>;\n}\n\nexport class APIError extends Error {\n  constructor(\n    message: string,\n    public status: number,\n    public response?: any,\n  ) {\n    super(message);\n    this.name = \"APIError\";\n  }\n}\n\nexport class AuthError extends APIError {\n  constructor(message: string = \"Authentication failed\") {\n    super(message, 401);\n    this.name = \"AuthError\";\n  }\n}\n\nexport class APIClient {\n  private client: typeof ky;\n  private isRefreshing = false;\n  private refreshPromise: Promise<void> | null = null;\n  private hooks: any;\n\n  constructor(\n    private config: APIConfig,\n    private authCallbacks?: AuthCallbacks,\n  ) {\n    this.hooks = {\n      beforeRequest: [\n        async (request: Request) => {\n          const tokens = await this.authCallbacks?.getTokens();\n          if (tokens?.accessToken) {\n            request.headers.set(\n              \"Authorization\",\n              `Bearer ${tokens.accessToken}`,\n            );\n          }\n        },\n      ],\n      beforeRetry: [\n        async ({ request, error, retryCount }: any) => {\n          if (error instanceof HTTPError && error.response.status === 401) {\n            if (retryCount === 1 && this.authCallbacks) {\n              try {\n                await this.refreshTokens();\n                const tokens = await this.authCallbacks.getTokens();\n                if (tokens?.accessToken) {\n                  request.headers.set(\n                    \"Authorization\",\n                    `Bearer ${tokens.accessToken}`,\n                  );\n                }\n              } catch (refreshError) {\n                this.authCallbacks.onAuthError?.();\n                throw new AuthError();\n              }\n            } else {\n              this.authCallbacks?.onAuthError?.();\n              throw new AuthError();\n            }\n          }\n        },\n      ],\n      beforeError: [\n        async (error: any) => {\n          const { response } = error;\n          if (response?.body) {\n            try {\n              const body = await response.json();\n              error.message =\n                (body as Error).message || `HTTP ${response.status}`;\n            } catch {\n              // Keep original message\n            }\n          }\n          return error;\n        },\n      ],\n    };\n\n    this.client = ky.create({\n      prefixUrl: this.config.baseUrl,\n      headers: {\n        \"Content-Type\": \"application/json\",\n      },\n      retry: {\n        limit: 2,\n        methods: [\"get\", \"post\", \"put\", \"delete\", \"patch\"],\n        statusCodes: [401],\n      },\n      hooks: this.hooks,\n    });\n  }\n\n  private async refreshTokens(): Promise<void> {\n    if (!this.authCallbacks) {\n      throw new AuthError(\"No auth callbacks provided\");\n    }\n\n    if (this.isRefreshing && this.refreshPromise) {\n      return this.refreshPromise;\n    }\n\n    this.isRefreshing = true;\n\n    this.refreshPromise = (async () => {\n      try {\n        if (this.authCallbacks?.onRefreshToken) {\n          await this.authCallbacks.onRefreshToken();\n        } else {\n          throw new AuthError(\"No refresh token handler provided\");\n        }\n      } catch (error) {\n        throw error;\n      } finally {\n        this.isRefreshing = false;\n        this.refreshPromise = null;\n      }\n    })();\n\n    return this.refreshPromise;\n  }\n\n  private buildPath(path: string, params?: Record<string, any>): string {\n    if (!params) return path;\n\n    let finalPath = path;\n    Object.entries(params).forEach(([key, value]) => {\n      finalPath = finalPath.replace(\n        `:${key}`,\n        encodeURIComponent(String(value)),\n      );\n    });\n\n    return finalPath;\n  }\n\n  private getEndpointBaseUrl(endpoint: APIEndpoint): string {\n    return endpoint.baseUrl || this.config.baseUrl!;\n  }\n\n  private getClientForEndpoint(endpoint: APIEndpoint): typeof ky {\n    const endpointBaseUrl = this.getEndpointBaseUrl(endpoint);\n\n    if (endpointBaseUrl === this.config.baseUrl) {\n      return this.client;\n    }\n\n    return ky.create({\n      prefixUrl: endpointBaseUrl,\n      headers: {\n        \"Content-Type\": \"application/json\",\n      },\n      retry: {\n        limit: 2,\n        methods: [\"get\", \"post\", \"put\", \"delete\", \"patch\"],\n        statusCodes: [401],\n      },\n      hooks: this.hooks,\n    });\n  }\n\n  async request<T>(\n    endpoint: APIEndpoint,\n    params?: Record<string, any>,\n    query?: Record<string, any>,\n    body?: any,\n  ): Promise<T> {\n    try {\n      const path = this.buildPath(endpoint.path, params);\n      const client = this.getClientForEndpoint(endpoint);\n\n      const options: Record<string, any> = {\n        method: endpoint.method,\n      };\n\n      if (query && Object.keys(query).length > 0) {\n        const searchParams = new URLSearchParams();\n        Object.entries(query).forEach(([key, value]) => {\n          if (value !== undefined && value !== null) {\n            searchParams.append(key, String(value));\n          }\n        });\n        if (searchParams.toString()) {\n          options.searchParams = searchParams;\n        }\n      }\n\n      if (body && endpoint.method !== \"GET\") {\n        if (endpoint.body) {\n          const validatedBody = endpoint.body.parse(body);\n          options.json = validatedBody;\n        } else {\n          options.json = body;\n        }\n      }\n\n      const response = await client(path, options);\n      const data = await response.json();\n\n      if (endpoint.response) {\n        return endpoint.response.parse(data);\n      }\n\n      return data as T;\n    } catch (error) {\n      if (error instanceof HTTPError) {\n        const errorData = await error.response.json().catch(() => ({}));\n        throw new APIError(\n          errorData.message || error.message,\n          error.response.status,\n          errorData,\n        );\n      }\n\n      if (error instanceof AuthError) {\n        throw error;\n      }\n\n      throw new APIError(\n        error instanceof Error ? error.message : \"Network error\",\n        0,\n      );\n    }\n  }\n\n  updateAuthCallbacks(authCallbacks: AuthCallbacks) {\n    this.authCallbacks = authCallbacks;\n  }\n\n  async refreshAuth(): Promise<void> {\n    if (!this.authCallbacks) {\n      throw new AuthError(\"No auth callbacks provided\");\n    }\n    await this.refreshTokens();\n  }\n\n  generateMethods() {\n    const methods: any = {};\n\n    Object.entries(this.config.endpoints).forEach(([name, endpoint]) => {\n      if (endpoint.method === \"GET\") {\n        if (endpoint.params && endpoint.query) {\n          methods[name] = (params: any, query?: any): Promise<any> => {\n            return this.request(endpoint, params, query);\n          };\n        } else if (endpoint.params) {\n          methods[name] = (params: any): Promise<any> => {\n            return this.request(endpoint, params);\n          };\n        } else if (endpoint.query) {\n          methods[name] = (query?: any): Promise<any> => {\n            return this.request(endpoint, undefined, query);\n          };\n        } else {\n          methods[name] = (): Promise<any> => {\n            return this.request(endpoint);\n          };\n        }\n      } else {\n        if (endpoint.params && endpoint.body) {\n          methods[name] = (params: any, body: any): Promise<any> => {\n            return this.request(endpoint, params, undefined, body);\n          };\n        } else if (endpoint.params) {\n          methods[name] = (params: any): Promise<any> => {\n            return this.request(endpoint, params);\n          };\n        } else if (endpoint.body) {\n          methods[name] = (body: any): Promise<any> => {\n            return this.request(endpoint, undefined, undefined, body);\n          };\n        } else {\n          methods[name] = (): Promise<any> => {\n            return this.request(endpoint);\n          };\n        }\n      }\n    });\n\n    return methods;\n  }\n}\n\nexport function createAPIClient(\n  config: APIConfig,\n  authCallbacks?: AuthCallbacks,\n) {\n  const instance = new APIClient(config, authCallbacks);\n  const methods = instance.generateMethods();\n\n  return {\n    ...methods,\n    refreshAuth: () => instance.refreshAuth(),\n    updateAuthCallbacks: (newCallbacks: AuthCallbacks) =>\n      instance.updateAuthCallbacks(newCallbacks),\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/client.d.ts

@@ -0,0 +1,40 @@
+import { APIConfig, APIEndpoint } from './schema.js';
+import 'zod';
+
+interface AuthTokens {
+    accessToken: string;
+    refreshToken?: string;
+}
+interface AuthCallbacks {
+    getTokens: () => Promise<AuthTokens | null>;
+    onAuthError?: () => void;
+    onRefreshToken?: () => Promise<void>;
+}
+declare class APIError extends Error {
+    status: number;
+    response?: any | undefined;
+    constructor(message: string, status: number, response?: any | undefined);
+}
+declare class AuthError extends APIError {
+    constructor(message?: string);
+}
+declare class APIClient {
+    private config;
+    private authCallbacks?;
+    private client;
+    private isRefreshing;
+    private refreshPromise;
+    private hooks;
+    constructor(config: APIConfig, authCallbacks?: AuthCallbacks | undefined);
+    private refreshTokens;
+    private buildPath;
+    private getEndpointBaseUrl;
+    private getClientForEndpoint;
+    request<T>(endpoint: APIEndpoint, params?: Record<string, any>, query?: Record<string, any>, body?: any): Promise<T>;
+    updateAuthCallbacks(authCallbacks: AuthCallbacks): void;
+    refreshAuth(): Promise<void>;
+    generateMethods(): any;
+}
+declare function createAPIClient(config: APIConfig, authCallbacks?: AuthCallbacks): any;
+
+export { APIClient, APIError, type AuthCallbacks, AuthError, type AuthTokens, createAPIClient };

package/dist/client.js

@@ -0,0 +1,13 @@
+import {
+  APIClient,
+  APIError,
+  AuthError,
+  createAPIClient
+} from "./chunk-RJFROHWK.js";
+export {
+  APIClient,
+  APIError,
+  AuthError,
+  createAPIClient
+};
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { APIConfig, APIEndpoint, EndpointConfig, HTTPMethod, defineConfig, defineEndpoint, defineEndpoints } from './schema.js';
+export { APIClient, APIError, AuthCallbacks, AuthError, AuthTokens, createAPIClient } from './client.js';
+import 'zod';

package/dist/index.js

@@ -0,0 +1,21 @@
+import {
+  APIClient,
+  APIError,
+  AuthError,
+  createAPIClient
+} from "./chunk-RJFROHWK.js";
+import {
+  defineConfig,
+  defineEndpoint,
+  defineEndpoints
+} from "./chunk-GL2GG37G.js";
+export {
+  APIClient,
+  APIError,
+  AuthError,
+  createAPIClient,
+  defineConfig,
+  defineEndpoint,
+  defineEndpoints
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+
+type HTTPMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface APIEndpoint {
+    path: string;
+    method: HTTPMethod;
+    baseUrl?: string;
+    params?: z.ZodType<any>;
+    query?: z.ZodType<any>;
+    body?: z.ZodType<any>;
+    response: z.ZodType<any>;
+    tags?: string[];
+    description?: string;
+}
+interface APIConfig {
+    baseUrl?: string;
+    endpoints: Record<string, APIEndpoint>;
+}
+type EndpointConfig<TPath extends string = string, TMethod extends HTTPMethod = HTTPMethod, TParams = undefined, TQuery = undefined, TBody = undefined, TResponse = any> = {
+    path: TPath;
+    method: TMethod;
+    baseUrl?: string;
+    params?: z.ZodType<TParams>;
+    query?: z.ZodType<TQuery>;
+    body?: z.ZodType<TBody>;
+    response: z.ZodType<TResponse>;
+    tags?: string[];
+    description?: string;
+};
+/**
+ * Helper function to define API configuration with type safety
+ */
+declare function defineConfig<T extends APIConfig>(config: T): T;
+/**
+ * Helper function to define a single endpoint with type inference
+ */
+declare function defineEndpoint<TPath extends string, TMethod extends HTTPMethod, TParams = undefined, TQuery = undefined, TBody = undefined, TResponse = any>(config: EndpointConfig<TPath, TMethod, TParams, TQuery, TBody, TResponse>): EndpointConfig<TPath, TMethod, TParams, TQuery, TBody, TResponse>;
+/**
+ * Helper to define multiple endpoints
+ */
+declare function defineEndpoints<T extends Record<string, APIEndpoint>>(endpoints: T): T;
+
+export { type APIConfig, type APIEndpoint, type EndpointConfig, type HTTPMethod, defineConfig, defineEndpoint, defineEndpoints };

package/dist/schema.js

@@ -0,0 +1,11 @@
+import {
+  defineConfig,
+  defineEndpoint,
+  defineEndpoints
+} from "./chunk-GL2GG37G.js";
+export {
+  defineConfig,
+  defineEndpoint,
+  defineEndpoints
+};
+//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@cushin/api-runtime",
+  "version": "2.0.1",
+  "description": "Runtime utilities for Cushin API codegen - types, schemas, and HTTP client",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "api",
+    "runtime",
+    "client",
+    "typescript",
+    "type-safe"
+  ],
+  "author": "Le Viet Hoang",
+  "license": "MIT",
+  "peerDependencies": {
+    "ky": "^1.0.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "ky": "^1.2.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "zod": "^3.25.76"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}