zenko 0.3.0-beta.1 → 0.3.0-beta.2

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.d.cts

@@ -1,4 +1,5 @@
-import { a as RouteNode, d as OperationErrors, f as PathFn, i as TreatyRoutesConstraint, l as HeaderFn, n as LeafCall, p as SecurityRequirement, r as TreatyClient, s as TreatyResult, t as createTreatyClient, u as OperationDefinition } from "./treaty-ZSSJQYZa.cjs";
+import { a as PathFn, i as OperationErrors, n as HeaderFn, r as OperationDefinition, s as SecurityRequirement } from "./types-BM-Q_QIk.cjs";
+import { a as RouteNode, i as TreatyRoutesConstraint, n as LeafCall, r as TreatyClient, s as TreatyResult, t as createTreatyClient } from "./treaty-NM6Hf8S8.cjs";
 
 //#region src/zenko.d.ts
 type OpenAPISpec = {

package/dist/index.d.mts

@@ -0,0 +1,63 @@
+import { a as PathFn, i as OperationErrors, n as HeaderFn, r as OperationDefinition, s as SecurityRequirement } from "./types-ByqlZjPK.mjs";
+import { a as RouteNode, i as TreatyRoutesConstraint, n as LeafCall, r as TreatyClient, s as TreatyResult, t as createTreatyClient } from "./treaty-DM77ZhDU.mjs";
+
+//#region src/zenko.d.ts
+type OpenAPISpec = {
+  openapi: string;
+  info: unknown;
+  paths: Record<string, Record<string, unknown>>;
+  webhooks?: Record<string, Record<string, unknown>>;
+  security?: Record<string, string[]>[];
+  components?: {
+    schemas?: Record<string, unknown>;
+    parameters?: Record<string, unknown>;
+    securitySchemes?: Record<string, unknown>;
+  };
+};
+type TypesHelperMode = "package" | "inline" | "file";
+type TypesConfig = {
+  emit?: boolean;
+  helpers?: TypesHelperMode;
+  helpersOutput?: string;
+  treeShake?: boolean;
+  optionalType?: "optional" | "nullable" | "nullish";
+  operationTypeSuffix?: string;
+};
+type EnumConfig = {
+  open?: boolean | string[];
+  unknownPrefix?: string;
+};
+type GenerateOptions = {
+  strictDates?: boolean;
+  strictNumeric?: boolean;
+  dateTimeOffset?: boolean | string[];
+  types?: TypesConfig;
+  operationIds?: string[];
+  openEnums?: boolean | string[] | EnumConfig;
+};
+/**
+ * Generates TypeScript client code from an OpenAPI specification.
+ *
+ * @param spec - The OpenAPI specification object.
+ * @param options - Configuration options controlling code generation behavior.
+ * @returns Generated TypeScript code as a string.
+ */
+declare function generate(spec: OpenAPISpec, options?: GenerateOptions): string;
+//#endregion
+//#region src/utils/treaty-tree.d.ts
+type OperationMeta = {
+  method: string;
+  path: string;
+};
+//#endregion
+//#region src/treaty-generator.d.ts
+declare function generateTreatyModuleFromMetadata(metadata: Record<string, OperationMeta>, options: {
+  importPath: string;
+}): string;
+declare function generateTreatyModule(options: {
+  inputFile: string;
+  importPath: string;
+}): Promise<string>;
+//#endregion
+export { type GenerateOptions, type HeaderFn, type LeafCall, type OpenAPISpec, type OperationDefinition, type OperationErrors, type PathFn, type RouteNode, type SecurityRequirement, type TreatyClient, type TreatyResult, type TreatyRoutesConstraint, type TypesConfig, createTreatyClient, generate, generateTreatyModule, generateTreatyModuleFromMetadata };
+//# sourceMappingURL=index.d.mts.map

package/dist/{treaty-ZSSJQYZa.d.cts → treaty-DM77ZhDU.d.mts}

@@ -1,22 +1,6 @@
+import { i as OperationErrors, o as RequestMethod, r as OperationDefinition, s as SecurityRequirement, t as AnyHeaderFn } from "./types-ByqlZjPK.mjs";
 import { z } from "zod";
 
-//#region src/types.d.ts
-type PathFn<TArgs extends unknown[] = []> = (...args: TArgs) => string;
-type RequestMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";
-type HeaderFn<TArgs extends unknown[] = [], TResult = Record<string, unknown> | Record<string, never>> = (...args: TArgs) => TResult;
-type AnyHeaderFn = HeaderFn<any, unknown> | (() => unknown);
-type OperationErrors<TError = unknown> = TError extends Record<string, unknown> ? TError : Record<string, TError>;
-type SecurityRequirement = Readonly<Record<string, readonly string[]>>;
-type OperationDefinition<TMethod extends RequestMethod, TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends AnyHeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined, TSecurity extends readonly SecurityRequirement[] | undefined = undefined> = {
-  method: TMethod;
-  path: TPath;
-  request?: TRequest;
-  response?: TResponse;
-  headers?: THeaders;
-  errors?: TErrors;
-  security?: TSecurity;
-};
-//#endregion
 //#region src/treaty-types.d.ts
 /** Nested route tree: segments, `:param` keys, and HTTP method leaves (see `isLeaf` in treaty runtime). */
 type RouteNode = Record<string, unknown>;
@@ -80,5 +64,5 @@ declare function createTreatyClient<const R extends TreatyRoutesConstraint>(conf
   fetch?: typeof fetch;
 }): TreatyClient<R>;
 //#endregion
-export { RouteNode as a, TreatySuccess as c, OperationErrors as d, PathFn as f, TreatyRoutesConstraint as i, HeaderFn as l, LeafCall as n, TreatyFailure as o, SecurityRequirement as p, TreatyClient as r, TreatyResult as s, createTreatyClient as t, OperationDefinition as u };
-//# sourceMappingURL=treaty-ZSSJQYZa.d.cts.map
+export { RouteNode as a, TreatySuccess as c, TreatyRoutesConstraint as i, LeafCall as n, TreatyFailure as o, TreatyClient as r, TreatyResult as s, createTreatyClient as t };
+//# sourceMappingURL=treaty-DM77ZhDU.d.mts.map

package/dist/treaty-NM6Hf8S8.d.cts

@@ -0,0 +1,68 @@
+import { i as OperationErrors, o as RequestMethod, r as OperationDefinition, s as SecurityRequirement, t as AnyHeaderFn } from "./types-BM-Q_QIk.cjs";
+import { z } from "zod";
+
+//#region src/treaty-types.d.ts
+/** Nested route tree: segments, `:param` keys, and HTTP method leaves (see `isLeaf` in treaty runtime). */
+type RouteNode = Record<string, unknown>;
+type TreatySuccess<T> = {
+  data: T;
+  error: null;
+  response: Response;
+  status: number;
+  headers: Headers;
+};
+type TreatyFailure = {
+  data: null;
+  error: {
+    status: number;
+    body: unknown;
+  };
+  response: Response;
+  status: number;
+  headers: Headers;
+};
+type TreatyResult<T> = TreatySuccess<T> | TreatyFailure;
+//#endregion
+//#region src/treaty-infer.d.ts
+type AnyOperationDefinition = OperationDefinition<RequestMethod, (...args: any[]) => string, unknown, unknown, AnyHeaderFn | undefined, OperationErrors | undefined, readonly SecurityRequirement[] | undefined>;
+type TreatyMethodOptions = RequestInit & {
+  query?: Record<string, unknown>;
+  headers?: Record<string, string>;
+};
+type InferZodOutput<Schema> = Schema extends z.ZodType ? z.infer<Schema> : unknown;
+type InferZodInput<Schema> = Schema extends z.ZodType ? z.input<Schema> : unknown;
+type SuccessData<Op extends AnyOperationDefinition> = NonNullable<Op["response"]> extends z.ZodType ? InferZodOutput<NonNullable<Op["response"]>> : unknown;
+/**
+ * Structural check: `Op["method"] extends "get" | "head"` is wrong when `method` is
+ * typed as `RequestMethod` (union) — it would match the GET branch incorrectly.
+ */
+type LeafCall<Op extends AnyOperationDefinition> = Op extends {
+  method: "get" | "head";
+} ? (opts?: {
+  query?: Record<string, unknown>;
+  headers?: Record<string, string>;
+}) => Promise<TreatyResult<SuccessData<Op>>> : Op extends {
+  request: infer Req;
+} ? Req extends z.ZodType ? (body: InferZodInput<Req>, init?: TreatyMethodOptions) => Promise<TreatyResult<SuccessData<Op>>> : (body?: unknown, init?: TreatyMethodOptions) => Promise<TreatyResult<SuccessData<Op>>> : (body?: unknown, init?: TreatyMethodOptions) => Promise<TreatyResult<SuccessData<Op>>>;
+type LeafMethods<R> = { [K in keyof R as K extends symbol ? never : R[K] extends AnyOperationDefinition ? K : never]: R[K] extends AnyOperationDefinition ? LeafCall<R[K]> : never };
+type DynamicParamKey<R> = Extract<keyof R, `:${string}`>;
+type ParamRecord<K extends `:${string}`> = K extends `:${infer Name}` ? { [P in Name]: string | number } : never;
+type DynamicBranch<R> = [DynamicParamKey<R>] extends [never] ? unknown : DynamicParamKey<R> extends infer K extends `:${string}` ? K extends keyof R ? (params: ParamRecord<K>) => TreatyClient<R[K]> : never : unknown;
+type StaticSegmentChildren<R> = { [K in keyof R as K extends symbol ? never : K extends `:${string}` ? never : R[K] extends AnyOperationDefinition ? never : R[K] extends Record<string, unknown> ? K : never]: R[K] extends Record<string, unknown> ? TreatyClient<R[K]> : never };
+/**
+ * Inferred Eden-style client for a nested `treatyRoutes` object whose leaves are
+ * {@link OperationDefinition} values (Zod-typed `request` / `response`).
+ */
+type TreatyClient<R> = LeafMethods<R> & StaticSegmentChildren<R> & DynamicBranch<R>;
+/** Permissive input constraint for `createTreatyClient` — inference comes from `routes`. */
+type TreatyRoutesConstraint = Record<string, unknown>;
+//#endregion
+//#region src/treaty.d.ts
+declare function createTreatyClient<const R extends TreatyRoutesConstraint>(config: {
+  baseUrl: string;
+  routes: R;
+  fetch?: typeof fetch;
+}): TreatyClient<R>;
+//#endregion
+export { RouteNode as a, TreatySuccess as c, TreatyRoutesConstraint as i, LeafCall as n, TreatyFailure as o, TreatyClient as r, TreatyResult as s, createTreatyClient as t };
+//# sourceMappingURL=treaty-NM6Hf8S8.d.cts.map

package/dist/treaty.d.cts

@@ -1,2 +1,2 @@
-import { a as RouteNode, c as TreatySuccess, i as TreatyRoutesConstraint, n as LeafCall, o as TreatyFailure, r as TreatyClient, s as TreatyResult, t as createTreatyClient } from "./treaty-ZSSJQYZa.cjs";
+import { a as RouteNode, c as TreatySuccess, i as TreatyRoutesConstraint, n as LeafCall, o as TreatyFailure, r as TreatyClient, s as TreatyResult, t as createTreatyClient } from "./treaty-NM6Hf8S8.cjs";
 export { LeafCall, RouteNode, TreatyClient, TreatyFailure, TreatyResult, TreatyRoutesConstraint, TreatySuccess, createTreatyClient };

package/dist/treaty.d.mts

@@ -0,0 +1,2 @@
+import { a as RouteNode, c as TreatySuccess, i as TreatyRoutesConstraint, n as LeafCall, o as TreatyFailure, r as TreatyClient, s as TreatyResult, t as createTreatyClient } from "./treaty-DM77ZhDU.mjs";
+export { LeafCall, RouteNode, TreatyClient, TreatyFailure, TreatyResult, TreatyRoutesConstraint, TreatySuccess, createTreatyClient };

package/dist/types-BM-Q_QIk.d.cts

@@ -0,0 +1,19 @@
+//#region src/types.d.ts
+type PathFn<TArgs extends unknown[] = []> = (...args: TArgs) => string;
+type RequestMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";
+type HeaderFn<TArgs extends unknown[] = [], TResult = Record<string, unknown> | Record<string, never>> = (...args: TArgs) => TResult;
+type AnyHeaderFn = HeaderFn<any, unknown> | (() => unknown);
+type OperationErrors<TError = unknown> = TError extends Record<string, unknown> ? TError : Record<string, TError>;
+type SecurityRequirement = Readonly<Record<string, readonly string[]>>;
+type OperationDefinition<TMethod extends RequestMethod, TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends AnyHeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined, TSecurity extends readonly SecurityRequirement[] | undefined = undefined> = {
+  method: TMethod;
+  path: TPath;
+  request?: TRequest;
+  response?: TResponse;
+  headers?: THeaders;
+  errors?: TErrors;
+  security?: TSecurity;
+};
+//#endregion
+export { PathFn as a, OperationErrors as i, HeaderFn as n, RequestMethod as o, OperationDefinition as r, SecurityRequirement as s, AnyHeaderFn as t };
+//# sourceMappingURL=types-BM-Q_QIk.d.cts.map

package/dist/types-ByqlZjPK.d.mts

@@ -0,0 +1,19 @@
+//#region src/types.d.ts
+type PathFn<TArgs extends unknown[] = []> = (...args: TArgs) => string;
+type RequestMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";
+type HeaderFn<TArgs extends unknown[] = [], TResult = Record<string, unknown> | Record<string, never>> = (...args: TArgs) => TResult;
+type AnyHeaderFn = HeaderFn<any, unknown> | (() => unknown);
+type OperationErrors<TError = unknown> = TError extends Record<string, unknown> ? TError : Record<string, TError>;
+type SecurityRequirement = Readonly<Record<string, readonly string[]>>;
+type OperationDefinition<TMethod extends RequestMethod, TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends AnyHeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined, TSecurity extends readonly SecurityRequirement[] | undefined = undefined> = {
+  method: TMethod;
+  path: TPath;
+  request?: TRequest;
+  response?: TResponse;
+  headers?: THeaders;
+  errors?: TErrors;
+  security?: TSecurity;
+};
+//#endregion
+export { PathFn as a, OperationErrors as i, HeaderFn as n, RequestMethod as o, OperationDefinition as r, SecurityRequirement as s, AnyHeaderFn as t };
+//# sourceMappingURL=types-ByqlZjPK.d.mts.map

package/dist/types.d.cts

@@ -0,0 +1,2 @@
+import { a as PathFn, i as OperationErrors, n as HeaderFn, o as RequestMethod, r as OperationDefinition, s as SecurityRequirement, t as AnyHeaderFn } from "./types-BM-Q_QIk.cjs";
+export { AnyHeaderFn, HeaderFn, OperationDefinition, OperationErrors, PathFn, RequestMethod, SecurityRequirement };

package/dist/types.d.mts

@@ -0,0 +1,2 @@
+import { a as PathFn, i as OperationErrors, n as HeaderFn, o as RequestMethod, r as OperationDefinition, s as SecurityRequirement, t as AnyHeaderFn } from "./types-ByqlZjPK.mjs";
+export { AnyHeaderFn, HeaderFn, OperationDefinition, OperationErrors, PathFn, RequestMethod, SecurityRequirement };

package/dist/types.mjs

@@ -0,0 +1 @@
+export{};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zenko",
-  "version": "0.3.0-beta.1",
+  "version": "0.3.0-beta.2",
   "description": "Generate TypeScript types and path functions from OpenAPI specs",
   "keywords": [
     "api",
@@ -29,28 +29,38 @@
     "README.md",
     "dist/**/*.cjs",
     "dist/**/*.d.cts",
+    "dist/**/*.d.mts",
     "dist/**/*.d.ts",
     "dist/**/*.mjs"
   ],
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
+      "types": {
+        "import": "./dist/index.d.mts",
+        "require": "./dist/index.d.cts"
+      },
       "bun": "./dist/index.mjs",
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
     },
     "./types": {
-      "types": "./dist/types.d.ts",
+      "types": {
+        "import": "./dist/types.d.mts",
+        "require": "./dist/types.d.cts"
+      },
       "bun": "./dist/types.mjs",
       "import": "./dist/types.mjs",
       "require": "./dist/types.cjs"
     },
     "./treaty": {
-      "types": "./dist/treaty.d.ts",
+      "types": {
+        "import": "./dist/treaty.d.mts",
+        "require": "./dist/treaty.d.cts"
+      },
       "bun": "./dist/treaty.mjs",
       "import": "./dist/treaty.mjs",
       "require": "./dist/treaty.cjs"