@geekmidas/client 10.0.0-alpha.2 → 10.0.0-alpha.21

package/dist/fetcher.d.mts

@@ -1,3 +1,23 @@
-import { FetcherOptions, WrappedResult } from "./types-BMGM6sZc.mjs";
-import { FetchFn, TypedFetcher, createTypedFetcher } from "./fetcher-C1xtCKpT.mjs";
-export { FetchFn, FetcherOptions, TypedFetcher, WrappedResult, createTypedFetcher };
+import { ErrorTransformer, ExtractEndpointResponse, FetcherOptions, FilteredRequestConfig, TypedEndpoint, WrappedResult } from "./types.mjs";
+import { MethodCalls } from "./methods.mjs";
+//#region src/fetcher.d.ts
+export declare class TypedFetcher<Paths> {
+  private baseURL;
+  private defaultHeaders;
+  private options;
+  private fetchFn;
+  static getFetchFn(fn?: FetchFn): FetchFn;
+  constructor(options?: FetcherOptions);
+  request<T extends TypedEndpoint<Paths>>(endpoint: T, config?: FilteredRequestConfig<Paths, T>): Promise<ExtractEndpointResponse<Paths, T>>;
+  wrap<E = unknown>(onError?: ErrorTransformer<E>): <T extends TypedEndpoint<Paths>>(endpoint: T, config?: FilteredRequestConfig<Paths, T>) => Promise<WrappedResult<ExtractEndpointResponse<Paths, T>, E>>;
+  private parseEndpoint;
+}
+export declare function createTypedFetcher<Paths>(options?: FetcherOptions): (<T extends TypedEndpoint<Paths>>(endpoint: T, config?: FilteredRequestConfig<Paths, T>) => Promise<ExtractEndpointResponse<Paths, T>>) & MethodCalls<Paths> & {
+  wrap: <E = unknown>(onError?: ErrorTransformer<E>) => (<T extends TypedEndpoint<Paths>>(endpoint: T, config?: FilteredRequestConfig<Paths, T> | undefined) => Promise<WrappedResult<ExtractEndpointResponse<Paths, T>, E>>) & (<T extends TypedEndpoint<Paths>>(endpoint: T, config?: FilteredRequestConfig<Paths, T>) => Promise<ExtractEndpointResponse<Paths, T>>) & {
+    wrap: undefined;
+  };
+};
+export type FetchFn = typeof fetch;
+//#endregion
+export type { FetcherOptions, WrappedResult };
+//# sourceMappingURL=fetcher.d.mts.map

package/dist/fetcher.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetcher.d.mts","names":["_$__methods0.MethodCalls"],"sources":["../src/fetcher.ts"],"mappings":";;;qBAgBa,aAAa;UACjB;UACA;UACA;UACA;SAED,WAAW,KAAK,UAAU;EAmBjC,YAAY,UAAS;EAOf,QAAQ,UAAU,cAAc,QACrC,UAAU,GACV,SAAS,sBAAsB,OAAO,KACpC,QAAQ,wBAAwB,OAAO;EAmF1C,KAAK,aAAa,UAAU,iBAAiB,MACpC,UAAU,cAAc,QAAM,UAC3B,GAAC,SACF,sBAAsB,OAAO,OACpC,QAAQ,cAAc,wBAAwB,OAAO,IAAI;UAUrD;;wBASO,mBAAmB,OAAO,UAAU,mBAEvC,UAAU,cAAc,QAAM,UAC/B,GAAC,SACF,sBAAsB,OAAO,OAAE,QAAA,wBAAA,OAAA,OAAAA,YAAA;EAIjC,OAAA,aAAW,UAAY,iBAAiB,SA9BvC,UAAU,cAAa,QAAO,UAAA,GAAA,SAAA,sBAAA,OAAA,mBAAA,QAAA,cAAA,wBAAA,OAAA,IAAA,SAwB3B,UAAU,cAAc,QAAM,UAC/B,GAAC,SACF,sBAAsB,OAAO,OAAE,QAAA,wBAAA,OAAA;;;;YAW9B,iBAAiB"}

package/dist/fetcher.mjs

@@ -1,3 +1,87 @@
-import { TypedFetcher, createTypedFetcher } from "./fetcher-CakjC9C7.mjs";
+import { methodCalls } from "./methods.mjs";
+import qs from "qs";
+//#region src/fetcher.ts
+var TypedFetcher = class TypedFetcher {
+	baseURL;
+	defaultHeaders;
+	options;
+	fetchFn;
+	static getFetchFn(fn) {
+		if (fn) return fn;
+		if (typeof window !== "undefined" && typeof window.fetch === "function") return window.fetch.bind(window);
+		if (typeof globalThis !== "undefined" && typeof globalThis.fetch === "function") return globalThis.fetch.bind(globalThis);
+		throw new Error("No fetch implementation found");
+	}
+	constructor(options = {}) {
+		this.baseURL = options.baseURL || "";
+		this.defaultHeaders = options.headers || {};
+		this.options = options;
+		this.fetchFn = TypedFetcher.getFetchFn(options.fetch);
+	}
+	async request(endpoint, config) {
+		const { method, route } = this.parseEndpoint(endpoint);
+		let url = route;
+		if (config && "params" in config && config.params) Object.entries(config.params).forEach(([key, value]) => {
+			url = url.replace(`{${key}}`, encodeURIComponent(String(value)));
+		});
+		if (config && "query" in config && config.query) {
+			const queryString = qs.stringify(config.query, {
+				encode: true,
+				arrayFormat: "brackets",
+				skipNulls: true
+			});
+			if (queryString) url += `?${queryString}`;
+		}
+		let requestConfig = {
+			method: method.toUpperCase(),
+			headers: {
+				...this.defaultHeaders,
+				...config && "headers" in config && config.headers || {}
+			}
+		};
+		if (config && "body" in config && config.body) {
+			requestConfig.body = JSON.stringify(config.body);
+			requestConfig.headers = {
+				...requestConfig.headers,
+				"Content-Type": "application/json"
+			};
+		}
+		if (this.options.onRequest) requestConfig = await this.options.onRequest(requestConfig);
+		try {
+			let response = await this.fetchFn(`${this.baseURL}${url}`, requestConfig);
+			if (this.options.onResponse) response = await this.options.onResponse(response);
+			if (!response.ok) throw response;
+			if (response.status === 204 || response.headers.get("content-length") === "0") return;
+			return await response.json();
+		} catch (error) {
+			if (this.options.onError) await this.options.onError(error);
+			throw error;
+		}
+	}
+	wrap(onError) {
+		return (endpoint, config) => this.request(endpoint, config).then((data) => ({
+			ok: true,
+			data
+		}), async (error) => ({
+			ok: false,
+			error: onError ? await onError(error) : error
+		}));
+	}
+	parseEndpoint(endpoint) {
+		const [method, ...routeParts] = endpoint.split(" ");
+		const route = routeParts.join(" ");
+		return {
+			method: method?.toLowerCase() ?? "",
+			route
+		};
+	}
+};
+function createTypedFetcher(options) {
+	const fetcher = new TypedFetcher(options);
+	const fn = (endpoint, config) => fetcher.request(endpoint, config);
+	return Object.assign(fn, methodCalls(fn), { wrap: (onError) => Object.assign(fetcher.wrap(onError), fn, { wrap: void 0 }) });
+}
+//#endregion
+export { TypedFetcher, createTypedFetcher };
 
-export { TypedFetcher, createTypedFetcher };
+//# sourceMappingURL=fetcher.mjs.map

package/dist/fetcher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetcher.mjs","names":[],"sources":["../src/fetcher.ts"],"sourcesContent":["import qs from 'qs';\nimport { methodCalls } from './methods';\nimport type {\n\tEndpointString,\n\tErrorTransformer,\n\tExtractEndpointResponse,\n\tFetcherOptions,\n\tFilteredRequestConfig,\n\tParseEndpoint,\n\tTypedApiFunction,\n\tTypedEndpoint,\n\tWrappedResult,\n} from './types';\n\nexport type { FetcherOptions, WrappedResult } from './types';\n\nexport class TypedFetcher<Paths> {\n\tprivate baseURL: string;\n\tprivate defaultHeaders: Record<string, string>;\n\tprivate options: FetcherOptions;\n\tprivate fetchFn: FetchFn;\n\n\tstatic getFetchFn(fn?: FetchFn): FetchFn {\n\t\tif (fn) {\n\t\t\treturn fn;\n\t\t}\n\n\t\tif (typeof window !== 'undefined' && typeof window.fetch === 'function') {\n\t\t\treturn window.fetch.bind(window);\n\t\t}\n\n\t\tif (\n\t\t\ttypeof globalThis !== 'undefined' &&\n\t\t\ttypeof globalThis.fetch === 'function'\n\t\t) {\n\t\t\treturn globalThis.fetch.bind(globalThis);\n\t\t}\n\n\t\tthrow new Error('No fetch implementation found');\n\t}\n\n\tconstructor(options: FetcherOptions = {}) {\n\t\tthis.baseURL = options.baseURL || '';\n\t\tthis.defaultHeaders = options.headers || {};\n\t\tthis.options = options;\n\t\tthis.fetchFn = TypedFetcher.getFetchFn(options.fetch);\n\t}\n\n\tasync request<T extends TypedEndpoint<Paths>>(\n\t\tendpoint: T,\n\t\tconfig?: FilteredRequestConfig<Paths, T>,\n\t): Promise<ExtractEndpointResponse<Paths, T>> {\n\t\tconst { method, route } = this.parseEndpoint(endpoint);\n\n\t\t// Replace path parameters\n\t\tlet url = route;\n\t\tif (config && 'params' in config && config.params) {\n\t\t\tObject.entries(config.params as Record<string, unknown>).forEach(\n\t\t\t\t([key, value]) => {\n\t\t\t\t\turl = url.replace(`{${key}}`, encodeURIComponent(String(value)));\n\t\t\t\t},\n\t\t\t);\n\t\t}\n\n\t\t// Add query parameters\n\t\tif (config && 'query' in config && config.query) {\n\t\t\tconst queryString = qs.stringify(config.query, {\n\t\t\t\tencode: true,\n\t\t\t\tarrayFormat: 'brackets',\n\t\t\t\tskipNulls: true,\n\t\t\t});\n\t\t\tif (queryString) {\n\t\t\t\turl += `?${queryString}`;\n\t\t\t}\n\t\t}\n\n\t\t// Build request configuration\n\t\tlet requestConfig: RequestInit = {\n\t\t\tmethod: method.toUpperCase(),\n\t\t\theaders: {\n\t\t\t\t...this.defaultHeaders,\n\t\t\t\t...((config && 'headers' in config && config.headers) || {}),\n\t\t\t},\n\t\t};\n\n\t\t// Add body if present\n\t\tif (config && 'body' in config && config.body) {\n\t\t\trequestConfig.body = JSON.stringify(config.body);\n\t\t\trequestConfig.headers = {\n\t\t\t\t...requestConfig.headers,\n\t\t\t\t'Content-Type': 'application/json',\n\t\t\t};\n\t\t}\n\n\t\t// Apply request interceptor\n\t\tif (this.options.onRequest) {\n\t\t\trequestConfig = await this.options.onRequest(requestConfig);\n\t\t}\n\n\t\ttry {\n\t\t\t// Make the request\n\t\t\tlet response = await this.fetchFn(`${this.baseURL}${url}`, requestConfig);\n\n\t\t\t// Apply response interceptor\n\t\t\tif (this.options.onResponse) {\n\t\t\t\tresponse = await this.options.onResponse(response);\n\t\t\t}\n\n\t\t\t// Handle errors\n\t\t\tif (!response.ok) {\n\t\t\t\tthrow response;\n\t\t\t}\n\n\t\t\t// Handle empty responses (204 No Content, etc.)\n\t\t\tif (\n\t\t\t\tresponse.status === 204 ||\n\t\t\t\tresponse.headers.get('content-length') === '0'\n\t\t\t) {\n\t\t\t\treturn undefined as ExtractEndpointResponse<Paths, T>;\n\t\t\t}\n\n\t\t\t// Parse JSON response\n\t\t\tconst data = await response.json();\n\t\t\treturn data as ExtractEndpointResponse<Paths, T>;\n\t\t} catch (error) {\n\t\t\t// Apply error handler\n\t\t\tif (this.options.onError) {\n\t\t\t\t// @ts-expect-error\n\t\t\t\tawait this.options.onError(error);\n\t\t\t}\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\twrap<E = unknown>(onError?: ErrorTransformer<E>) {\n\t\treturn <T extends TypedEndpoint<Paths>>(\n\t\t\tendpoint: T,\n\t\t\tconfig?: FilteredRequestConfig<Paths, T>,\n\t\t): Promise<WrappedResult<ExtractEndpointResponse<Paths, T>, E>> =>\n\t\t\tthis.request(endpoint, config).then(\n\t\t\t\t(data) => ({ ok: true as const, data }),\n\t\t\t\tasync (error) => ({\n\t\t\t\t\tok: false as const,\n\t\t\t\t\terror: onError ? await onError(error) : (error as E),\n\t\t\t\t}),\n\t\t\t);\n\t}\n\n\tprivate parseEndpoint<T extends EndpointString>(\n\t\tendpoint: T,\n\t): ParseEndpoint<T> {\n\t\tconst [method, ...routeParts] = endpoint.split(' ');\n\t\tconst route = routeParts.join(' ');\n\t\treturn { method: method?.toLowerCase() ?? '', route } as ParseEndpoint<T>;\n\t}\n}\n\nexport function createTypedFetcher<Paths>(options?: FetcherOptions) {\n\tconst fetcher = new TypedFetcher<Paths>(options);\n\tconst fn = <T extends TypedEndpoint<Paths>>(\n\t\tendpoint: T,\n\t\tconfig?: FilteredRequestConfig<Paths, T>,\n\t) => fetcher.request(endpoint, config);\n\n\treturn Object.assign(fn, methodCalls<Paths>(fn as TypedApiFunction<Paths>), {\n\t\twrap: <E = unknown>(onError?: ErrorTransformer<E>) =>\n\t\t\tObject.assign(fetcher.wrap(onError), fn, {\n\t\t\t\twrap: undefined,\n\t\t\t}),\n\t});\n}\n\nexport type FetchFn = typeof fetch;\n"],"mappings":";;;AAgBA,IAAa,eAAb,MAAa,aAAoB;CAChC;CACA;CACA;CACA;CAEA,OAAO,WAAW,IAAuB;EACxC,IAAI,IACH,OAAO;EAGR,IAAI,OAAO,WAAW,eAAe,OAAO,OAAO,UAAU,YAC5D,OAAO,OAAO,MAAM,KAAK,MAAM;EAGhC,IACC,OAAO,eAAe,eACtB,OAAO,WAAW,UAAU,YAE5B,OAAO,WAAW,MAAM,KAAK,UAAU;EAGxC,MAAM,IAAI,MAAM,+BAA+B;CAChD;CAEA,YAAY,UAA0B,CAAC,GAAG;EACzC,KAAK,UAAU,QAAQ,WAAW;EAClC,KAAK,iBAAiB,QAAQ,WAAW,CAAC;EAC1C,KAAK,UAAU;EACf,KAAK,UAAU,aAAa,WAAW,QAAQ,KAAK;CACrD;CAEA,MAAM,QACL,UACA,QAC6C;EAC7C,MAAM,EAAE,QAAQ,UAAU,KAAK,cAAc,QAAQ;EAGrD,IAAI,MAAM;EACV,IAAI,UAAU,YAAY,UAAU,OAAO,QAC1C,OAAO,QAAQ,OAAO,MAAiC,CAAC,CAAC,SACvD,CAAC,KAAK,WAAW;GACjB,MAAM,IAAI,QAAQ,IAAI,IAAI,IAAI,mBAAmB,OAAO,KAAK,CAAC,CAAC;EAChE,CACD;EAID,IAAI,UAAU,WAAW,UAAU,OAAO,OAAO;GAChD,MAAM,cAAc,GAAG,UAAU,OAAO,OAAO;IAC9C,QAAQ;IACR,aAAa;IACb,WAAW;GACZ,CAAC;GACD,IAAI,aACH,OAAO,IAAI;EAEb;EAGA,IAAI,gBAA6B;GAChC,QAAQ,OAAO,YAAY;GAC3B,SAAS;IACR,GAAG,KAAK;IACR,GAAK,UAAU,aAAa,UAAU,OAAO,WAAY,CAAC;GAC3D;EACD;EAGA,IAAI,UAAU,UAAU,UAAU,OAAO,MAAM;GAC9C,cAAc,OAAO,KAAK,UAAU,OAAO,IAAI;GAC/C,cAAc,UAAU;IACvB,GAAG,cAAc;IACjB,gBAAgB;GACjB;EACD;EAGA,IAAI,KAAK,QAAQ,WAChB,gBAAgB,MAAM,KAAK,QAAQ,UAAU,aAAa;EAG3D,IAAI;GAEH,IAAI,WAAW,MAAM,KAAK,QAAQ,GAAG,KAAK,UAAU,OAAO,aAAa;GAGxE,IAAI,KAAK,QAAQ,YAChB,WAAW,MAAM,KAAK,QAAQ,WAAW,QAAQ;GAIlD,IAAI,CAAC,SAAS,IACb,MAAM;GAIP,IACC,SAAS,WAAW,OACpB,SAAS,QAAQ,IAAI,gBAAgB,MAAM,KAE3C;GAKD,OAAO,MADY,SAAS,KAAK;EAElC,SAAS,OAAO;GAEf,IAAI,KAAK,QAAQ,SAEhB,MAAM,KAAK,QAAQ,QAAQ,KAAK;GAEjC,MAAM;EACP;CACD;CAEA,KAAkB,SAA+B;EAChD,QACC,UACA,WAEA,KAAK,QAAQ,UAAU,MAAM,CAAC,CAAC,MAC7B,UAAU;GAAE,IAAI;GAAe;EAAK,IACrC,OAAO,WAAW;GACjB,IAAI;GACJ,OAAO,UAAU,MAAM,QAAQ,KAAK,IAAK;EAC1C,EACD;CACF;CAEA,cACC,UACmB;EACnB,MAAM,CAAC,QAAQ,GAAG,cAAc,SAAS,MAAM,GAAG;EAClD,MAAM,QAAQ,WAAW,KAAK,GAAG;EACjC,OAAO;GAAE,QAAQ,QAAQ,YAAY,KAAK;GAAI;EAAM;CACrD;AACD;AAEA,SAAgB,mBAA0B,SAA0B;CACnE,MAAM,UAAU,IAAI,aAAoB,OAAO;CAC/C,MAAM,MACL,UACA,WACI,QAAQ,QAAQ,UAAU,MAAM;CAErC,OAAO,OAAO,OAAO,IAAI,YAAmB,EAA6B,GAAG,EAC3E,OAAoB,YACnB,OAAO,OAAO,QAAQ,KAAK,OAAO,GAAG,IAAI,EACxC,MAAM,KAAA,EACP,CAAC,EACH,CAAC;AACF"}

package/dist/index.cjs

@@ -1,8 +1,11 @@
-const require_fetcher = require('./fetcher-CwnSqc4D.cjs');
-const require_auth_fetcher = require('./auth-fetcher-HILABmws.cjs');
-require('./infer-6KKCgmg1.cjs');
-require('./types-a8gm_IaQ.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_methods = require("./methods.cjs");
+const require_fetcher = require("./fetcher.cjs");
+const require_auth_fetcher = require("./auth-fetcher.cjs");
+require("./infer.cjs");
+require("./types.cjs");
+exports.CALL_METHODS = require_methods.CALL_METHODS;
 exports.TypedFetcher = require_fetcher.TypedFetcher;
 exports.createAuthAwareFetcher = require_auth_fetcher.createAuthAwareFetcher;
-exports.createTypedFetcher = require_fetcher.createTypedFetcher;
+exports.createTypedFetcher = require_fetcher.createTypedFetcher;
+exports.methodCalls = require_methods.methodCalls;

package/dist/index.d.cts

@@ -1,5 +1,6 @@
-import { EndpointString, ErrorTransformer, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, IsConfigRequired, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedApiFunction, TypedEndpoint, ValidEndpoint, WrappedApiFunction, WrappedResult } from "./types-DMQMHePI.cjs";
-import { ApiKeyProvider, AuthFetcherOptions, AuthStrategy, AuthenticatedEndpoints, AwsSigner, GetEndpointAuth, PublicEndpoints, SecuritySchemeObject, TokenProvider, UsedSecuritySchemes, createAuthAwareFetcher } from "./auth-fetcher-CBYuL6rx.cjs";
-import { FetchFn, TypedFetcher, createTypedFetcher } from "./fetcher-cDrfwN-Y.cjs";
-import { InferOpenApi, InferOpenApiFromEndpoint } from "./infer-DfRq5kIb.cjs";
-export { ApiKeyProvider, AuthFetcherOptions, AuthStrategy, AuthenticatedEndpoints, AwsSigner, EndpointString, ErrorTransformer, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetchFn, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, GetEndpointAuth, InferOpenApi, InferOpenApiFromEndpoint, IsConfigRequired, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, PublicEndpoints, QueryEndpoint, RequestConfig, SecuritySchemeObject, TokenProvider, TypedApiFunction, TypedEndpoint, TypedFetcher, UsedSecuritySchemes, ValidEndpoint, WrappedApiFunction, WrappedResult, createAuthAwareFetcher, createTypedFetcher };
+import { EndpointString, ErrorTransformer, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, IsConfigRequired, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedApiFunction, TypedEndpoint, ValidEndpoint, WrappedApiFunction, WrappedResult } from "./types.cjs";
+import { ApiKeyProvider, AuthFetcherOptions, AuthStrategy, AuthenticatedEndpoints, AwsSigner, GetEndpointAuth, PublicEndpoints, SecuritySchemeObject, TokenProvider, UsedSecuritySchemes, createAuthAwareFetcher } from "./auth-fetcher.cjs";
+import { CALL_METHODS, CallMethod, MethodCall, MethodCalls, RoutesFor, methodCalls } from "./methods.cjs";
+import { FetchFn, TypedFetcher, createTypedFetcher } from "./fetcher.cjs";
+import { InferOpenApi, InferOpenApiFromEndpoint } from "./infer.cjs";
+export { ApiKeyProvider, AuthFetcherOptions, AuthStrategy, AuthenticatedEndpoints, AwsSigner, CALL_METHODS, CallMethod, EndpointString, ErrorTransformer, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetchFn, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, GetEndpointAuth, InferOpenApi, InferOpenApiFromEndpoint, IsConfigRequired, MethodCall, MethodCalls, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, PublicEndpoints, QueryEndpoint, RequestConfig, RoutesFor, SecuritySchemeObject, TokenProvider, TypedApiFunction, TypedEndpoint, TypedFetcher, UsedSecuritySchemes, ValidEndpoint, WrappedApiFunction, WrappedResult, createAuthAwareFetcher, createTypedFetcher, methodCalls };

package/dist/index.d.mts

@@ -1,5 +1,6 @@
-import { EndpointString, ErrorTransformer, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, IsConfigRequired, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedApiFunction, TypedEndpoint, ValidEndpoint, WrappedApiFunction, WrappedResult } from "./types-BMGM6sZc.mjs";
-import { ApiKeyProvider, AuthFetcherOptions, AuthStrategy, AuthenticatedEndpoints, AwsSigner, GetEndpointAuth, PublicEndpoints, SecuritySchemeObject, TokenProvider, UsedSecuritySchemes, createAuthAwareFetcher } from "./auth-fetcher-DxS8zOLc.mjs";
-import { FetchFn, TypedFetcher, createTypedFetcher } from "./fetcher-C1xtCKpT.mjs";
-import { InferOpenApi, InferOpenApiFromEndpoint } from "./infer-bTirNeNW.mjs";
-export { ApiKeyProvider, AuthFetcherOptions, AuthStrategy, AuthenticatedEndpoints, AwsSigner, EndpointString, ErrorTransformer, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetchFn, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, GetEndpointAuth, InferOpenApi, InferOpenApiFromEndpoint, IsConfigRequired, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, PublicEndpoints, QueryEndpoint, RequestConfig, SecuritySchemeObject, TokenProvider, TypedApiFunction, TypedEndpoint, TypedFetcher, UsedSecuritySchemes, ValidEndpoint, WrappedApiFunction, WrappedResult, createAuthAwareFetcher, createTypedFetcher };
+import { EndpointString, ErrorTransformer, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, IsConfigRequired, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, QueryEndpoint, RequestConfig, TypedApiFunction, TypedEndpoint, ValidEndpoint, WrappedApiFunction, WrappedResult } from "./types.mjs";
+import { ApiKeyProvider, AuthFetcherOptions, AuthStrategy, AuthenticatedEndpoints, AwsSigner, GetEndpointAuth, PublicEndpoints, SecuritySchemeObject, TokenProvider, UsedSecuritySchemes, createAuthAwareFetcher } from "./auth-fetcher.mjs";
+import { CALL_METHODS, CallMethod, MethodCall, MethodCalls, RoutesFor, methodCalls } from "./methods.mjs";
+import { FetchFn, TypedFetcher, createTypedFetcher } from "./fetcher.mjs";
+import { InferOpenApi, InferOpenApiFromEndpoint } from "./infer.mjs";
+export { ApiKeyProvider, AuthFetcherOptions, AuthStrategy, AuthenticatedEndpoints, AwsSigner, CALL_METHODS, CallMethod, EndpointString, ErrorTransformer, ExtractEndpointConfig, ExtractEndpointResponse, ExtractMethod, ExtractPathParams, ExtractQueryParams, ExtractRequestBody, ExtractResponse, FetchFn, FetcherOptions, FilterEndpointByMethod, FilteredRequestConfig, GetEndpointAuth, InferOpenApi, InferOpenApiFromEndpoint, IsConfigRequired, MethodCall, MethodCalls, MutationEndpoint, OpenAPIRoutes, ParseEndpoint, PublicEndpoints, QueryEndpoint, RequestConfig, RoutesFor, SecuritySchemeObject, TokenProvider, TypedApiFunction, TypedEndpoint, TypedFetcher, UsedSecuritySchemes, ValidEndpoint, WrappedApiFunction, WrappedResult, createAuthAwareFetcher, createTypedFetcher, methodCalls };

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { TypedFetcher, createTypedFetcher } from "./fetcher-CakjC9C7.mjs";
-import { createAuthAwareFetcher } from "./auth-fetcher-DOj0iz21.mjs";
-import "./infer-uCUq1whM.mjs";
-import "./types-BH8WgGrm.mjs";
-
-export { TypedFetcher, createAuthAwareFetcher, createTypedFetcher };
+import { CALL_METHODS, methodCalls } from "./methods.mjs";
+import { TypedFetcher, createTypedFetcher } from "./fetcher.mjs";
+import { createAuthAwareFetcher } from "./auth-fetcher.mjs";
+import "./infer.mjs";
+import "./types.mjs";
+export { CALL_METHODS, TypedFetcher, createAuthAwareFetcher, createTypedFetcher, methodCalls };

package/dist/infer.cjs

@@ -1 +0,0 @@
-require('./infer-6KKCgmg1.cjs');

package/dist/infer.d.cts

@@ -1,2 +1,130 @@
-import { InferOpenApi, InferOpenApiFromEndpoint } from "./infer-DfRq5kIb.cjs";
-export { InferOpenApi, InferOpenApiFromEndpoint };
+import { ConvertRouteParams, Endpoint, EndpointSchemas } from "@geekmidas/constructs/endpoints";
+import { HttpMethod } from "@geekmidas/constructs/types";
+import { InferStandardSchema, InferStandardSchemaInput } from "@geekmidas/schema";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/infer.d.ts
+/**
+ * Infers path parameters from a route string as an object
+ * @example '/users/{id}/posts/{postId}' -> { id: string, postId: string }
+ */
+type InferPathParams<TRoute extends string> = TRoute extends `${string}{${infer Param}}${infer Rest}` ? { [K in Param]: string; } & InferPathParams<Rest> : {};
+/**
+ * Converts an HTTP method to lowercase for TypedFetcher compatibility
+ */
+type LowercaseMethod<T extends HttpMethod> = Lowercase<T>;
+/**
+ * Infers route-level parameters (path params)
+ */
+type InferRouteParameters<TRoute extends string> = InferPathParams<TRoute> extends Record<string, never> ? {} : {
+  parameters: {
+    path: InferPathParams<TRoute>;
+  };
+};
+/**
+ * Infers operation-level parameters (query params)
+ */
+type InferOperationParameters<TInput extends EndpointSchemas> = TInput extends {
+  query: infer Q;
+} ? {
+  parameters: {
+    query: InferStandardSchemaInput<Q>;
+  };
+} : {};
+/**
+ * Infers the operation object compatible with TypedFetcher
+ */
+type InferOperation<TInput extends EndpointSchemas, TOutput extends StandardSchemaV1 | undefined> = InferOperationParameters<TInput> & {
+  requestBody?: TInput extends {
+    body: infer B;
+  } ? {
+    content: {
+      'application/json': InferStandardSchemaInput<B>;
+    };
+  } : never;
+  responses: {
+    200: {
+      content: TOutput extends StandardSchemaV1 ? {
+        'application/json': InferStandardSchema<TOutput>;
+      } : never;
+    };
+  };
+};
+/**
+ * Infers the TypedFetcher-compatible paths structure from a single endpoint
+ *
+ * This generates a structure compatible with @geekmidas/client TypedFetcher,
+ * allowing you to create a typed client directly from endpoint definitions
+ * without needing OpenAPI JSON + codegen.
+ *
+ * @example
+ * ```typescript
+ * import { api } from './constructs/api.js';
+ * import { createTypedFetcher, type InferOpenApiFromEndpoint } from '@geekmidas/client';
+ * import { z } from 'zod';
+ *
+ * const endpoint = e
+ *   .get('/users/{id}')
+ *   .params(z.object({ id: z.string() }))
+ *   .output(z.object({ id: z.string(), name: z.string() }))
+ *   .handle(async ({ params }) => ({ id: params.id, name: 'John' }));
+ *
+ * type Paths = InferOpenApiFromEndpoint<typeof endpoint>['paths'];
+ * const client = createTypedFetcher<Paths>({ baseURL: 'http://localhost:3000' });
+ * const user = await client('GET /users/{id}', { params: { id: '123' } });
+ * ```
+ */
+export type InferOpenApiFromEndpoint<T> = T extends Endpoint<infer TRoute, infer TMethod, infer TInput, infer TOutput, any, any, any> ? {
+  paths: { [K in ConvertRouteParams<TRoute>]: InferRouteParameters<ConvertRouteParams<TRoute>> & { [M in LowercaseMethod<TMethod>]: InferOperation<TInput, TOutput>; }; };
+} : never;
+/**
+ * Infers TypedFetcher-compatible paths structure from multiple endpoints
+ *
+ * Merges multiple endpoint definitions into a single paths object that can be
+ * used with @geekmidas/client TypedFetcher for fully type-safe API calls.
+ *
+ * @example
+ * ```typescript
+ * import { api } from './constructs/api.js';
+ * import { createTypedFetcher, type InferOpenApi } from '@geekmidas/client';
+ * import { z } from 'zod';
+ *
+ * // Define endpoints
+ * const getUserEndpoint = e
+ *   .get('/users/{id}')
+ *   .params(z.object({ id: z.string() }))
+ *   .output(z.object({ id: z.string(), name: z.string() }))
+ *   .handle(async ({ params }) => ({ id: params.id, name: 'John' }));
+ *
+ * const createUserEndpoint = e
+ *   .post('/users')
+ *   .body(z.object({ name: z.string() }))
+ *   .output(z.object({ id: z.string(), name: z.string() }))
+ *   .handle(async ({ body }) => ({ id: '123', name: body.name }));
+ *
+ * // Export for client
+ * export const endpoints = [getUserEndpoint, createUserEndpoint] as const;
+ * export type Paths = InferOpenApi<typeof endpoints>['paths'];
+ *
+ * // Client usage
+ * import type { Paths } from './endpoints';
+ * const client = createTypedFetcher<Paths>({ baseURL: 'http://localhost:3000' });
+ *
+ * const user = await client('GET /users/{id}', { params: { id: '123' } });
+ * const newUser = await client('POST /users', { body: { name: 'Jane' } });
+ * ```
+ */
+export type InferOpenApi<TEndpoints extends readonly any[]> = TEndpoints extends readonly [infer First, ...infer Rest] ? InferOpenApiFromEndpoint<First> extends {
+  paths: infer P1;
+} ? Rest extends [] ? {
+  paths: P1;
+} : InferOpenApi<Rest> extends {
+  paths: infer P2;
+} ? {
+  paths: P1 & P2;
+} : {
+  paths: P1;
+} : InferOpenApi<Rest> : {
+  paths: {};
+};
+//#endregion
+//# sourceMappingURL=infer.d.cts.map

package/dist/infer.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer.d.cts","names":[],"sources":["../src/infer.ts"],"mappings":";;;;;;;;;KAgBK,gBAAgB,yBACpB,kCAAkC,eAAe,YAC3C,KAAK,oBAAmB,gBAAgB;;;;KAM1C,gBAAgB,UAAU,cAAc,UAAU;;;;KAKlD,qBAAqB,yBACzB,gBAAgB,gBAAgB;EAG7B;IACC,MAAM,gBAAgB;;;;;;KAOtB,yBAAyB,eAAe,mBAAmB;EAC/D,aAAa;;EAGX;IAMC,OAAO,yBAAyB;;;;;;KAQ/B,eACJ,eAAe,iBACf,gBAAgB,gCACb,yBAAyB;EAC5B,cAAc;IAAiB,YAAY;;IAExC;MAKC,oBAAoB,yBAAyB;;;EAIjD;IACC;MACC,SAAS,gBAAgB;QAEtB,oBAAoB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA+BlC,yBAAyB,KACpC,UAAU,eACH,cACA,eACA,cACA;EAUJ,UACE,KAAK,mBAAmB,UAAU,qBAClC,mBAAmB,cAElB,KAAK,gBAAgB,WAAW,eAAe,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2ClD,aAAa,qCACxB,mCAAmC,gBAAgB,QAChD,yBAAyB;EAAiB,aAAa;IACtD;EACG,OAAO;IACT,aAAa;EAAgB,aAAa;;EACvC,OAAO,KAAK;;EACZ,OAAO;IACX,aAAa;EACZ"}

package/dist/infer.d.mts

@@ -1,2 +1,130 @@
-import { InferOpenApi, InferOpenApiFromEndpoint } from "./infer-bTirNeNW.mjs";
-export { InferOpenApi, InferOpenApiFromEndpoint };
+import { ConvertRouteParams, Endpoint, EndpointSchemas } from "@geekmidas/constructs/endpoints";
+import { HttpMethod } from "@geekmidas/constructs/types";
+import { InferStandardSchema, InferStandardSchemaInput } from "@geekmidas/schema";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/infer.d.ts
+/**
+ * Infers path parameters from a route string as an object
+ * @example '/users/{id}/posts/{postId}' -> { id: string, postId: string }
+ */
+type InferPathParams<TRoute extends string> = TRoute extends `${string}{${infer Param}}${infer Rest}` ? { [K in Param]: string; } & InferPathParams<Rest> : {};
+/**
+ * Converts an HTTP method to lowercase for TypedFetcher compatibility
+ */
+type LowercaseMethod<T extends HttpMethod> = Lowercase<T>;
+/**
+ * Infers route-level parameters (path params)
+ */
+type InferRouteParameters<TRoute extends string> = InferPathParams<TRoute> extends Record<string, never> ? {} : {
+  parameters: {
+    path: InferPathParams<TRoute>;
+  };
+};
+/**
+ * Infers operation-level parameters (query params)
+ */
+type InferOperationParameters<TInput extends EndpointSchemas> = TInput extends {
+  query: infer Q;
+} ? {
+  parameters: {
+    query: InferStandardSchemaInput<Q>;
+  };
+} : {};
+/**
+ * Infers the operation object compatible with TypedFetcher
+ */
+type InferOperation<TInput extends EndpointSchemas, TOutput extends StandardSchemaV1 | undefined> = InferOperationParameters<TInput> & {
+  requestBody?: TInput extends {
+    body: infer B;
+  } ? {
+    content: {
+      'application/json': InferStandardSchemaInput<B>;
+    };
+  } : never;
+  responses: {
+    200: {
+      content: TOutput extends StandardSchemaV1 ? {
+        'application/json': InferStandardSchema<TOutput>;
+      } : never;
+    };
+  };
+};
+/**
+ * Infers the TypedFetcher-compatible paths structure from a single endpoint
+ *
+ * This generates a structure compatible with @geekmidas/client TypedFetcher,
+ * allowing you to create a typed client directly from endpoint definitions
+ * without needing OpenAPI JSON + codegen.
+ *
+ * @example
+ * ```typescript
+ * import { api } from './constructs/api.js';
+ * import { createTypedFetcher, type InferOpenApiFromEndpoint } from '@geekmidas/client';
+ * import { z } from 'zod';
+ *
+ * const endpoint = e
+ *   .get('/users/{id}')
+ *   .params(z.object({ id: z.string() }))
+ *   .output(z.object({ id: z.string(), name: z.string() }))
+ *   .handle(async ({ params }) => ({ id: params.id, name: 'John' }));
+ *
+ * type Paths = InferOpenApiFromEndpoint<typeof endpoint>['paths'];
+ * const client = createTypedFetcher<Paths>({ baseURL: 'http://localhost:3000' });
+ * const user = await client('GET /users/{id}', { params: { id: '123' } });
+ * ```
+ */
+export type InferOpenApiFromEndpoint<T> = T extends Endpoint<infer TRoute, infer TMethod, infer TInput, infer TOutput, any, any, any> ? {
+  paths: { [K in ConvertRouteParams<TRoute>]: InferRouteParameters<ConvertRouteParams<TRoute>> & { [M in LowercaseMethod<TMethod>]: InferOperation<TInput, TOutput>; }; };
+} : never;
+/**
+ * Infers TypedFetcher-compatible paths structure from multiple endpoints
+ *
+ * Merges multiple endpoint definitions into a single paths object that can be
+ * used with @geekmidas/client TypedFetcher for fully type-safe API calls.
+ *
+ * @example
+ * ```typescript
+ * import { api } from './constructs/api.js';
+ * import { createTypedFetcher, type InferOpenApi } from '@geekmidas/client';
+ * import { z } from 'zod';
+ *
+ * // Define endpoints
+ * const getUserEndpoint = e
+ *   .get('/users/{id}')
+ *   .params(z.object({ id: z.string() }))
+ *   .output(z.object({ id: z.string(), name: z.string() }))
+ *   .handle(async ({ params }) => ({ id: params.id, name: 'John' }));
+ *
+ * const createUserEndpoint = e
+ *   .post('/users')
+ *   .body(z.object({ name: z.string() }))
+ *   .output(z.object({ id: z.string(), name: z.string() }))
+ *   .handle(async ({ body }) => ({ id: '123', name: body.name }));
+ *
+ * // Export for client
+ * export const endpoints = [getUserEndpoint, createUserEndpoint] as const;
+ * export type Paths = InferOpenApi<typeof endpoints>['paths'];
+ *
+ * // Client usage
+ * import type { Paths } from './endpoints';
+ * const client = createTypedFetcher<Paths>({ baseURL: 'http://localhost:3000' });
+ *
+ * const user = await client('GET /users/{id}', { params: { id: '123' } });
+ * const newUser = await client('POST /users', { body: { name: 'Jane' } });
+ * ```
+ */
+export type InferOpenApi<TEndpoints extends readonly any[]> = TEndpoints extends readonly [infer First, ...infer Rest] ? InferOpenApiFromEndpoint<First> extends {
+  paths: infer P1;
+} ? Rest extends [] ? {
+  paths: P1;
+} : InferOpenApi<Rest> extends {
+  paths: infer P2;
+} ? {
+  paths: P1 & P2;
+} : {
+  paths: P1;
+} : InferOpenApi<Rest> : {
+  paths: {};
+};
+//#endregion
+//# sourceMappingURL=infer.d.mts.map

package/dist/infer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer.d.mts","names":[],"sources":["../src/infer.ts"],"mappings":";;;;;;;;;KAgBK,gBAAgB,yBACpB,kCAAkC,eAAe,YAC3C,KAAK,oBAAmB,gBAAgB;;;;KAM1C,gBAAgB,UAAU,cAAc,UAAU;;;;KAKlD,qBAAqB,yBACzB,gBAAgB,gBAAgB;EAG7B;IACC,MAAM,gBAAgB;;;;;;KAOtB,yBAAyB,eAAe,mBAAmB;EAC/D,aAAa;;EAGX;IAMC,OAAO,yBAAyB;;;;;;KAQ/B,eACJ,eAAe,iBACf,gBAAgB,gCACb,yBAAyB;EAC5B,cAAc;IAAiB,YAAY;;IAExC;MAKC,oBAAoB,yBAAyB;;;EAIjD;IACC;MACC,SAAS,gBAAgB;QAEtB,oBAAoB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA+BlC,yBAAyB,KACpC,UAAU,eACH,cACA,eACA,cACA;EAUJ,UACE,KAAK,mBAAmB,UAAU,qBAClC,mBAAmB,cAElB,KAAK,gBAAgB,WAAW,eAAe,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2ClD,aAAa,qCACxB,mCAAmC,gBAAgB,QAChD,yBAAyB;EAAiB,aAAa;IACtD;EACG,OAAO;IACT,aAAa;EAAgB,aAAa;;EACvC,OAAO,KAAK;;EACZ,OAAO;IACX,aAAa;EACZ"}

package/dist/infer.mjs

@@ -1 +1 @@
-import "./infer-uCUq1whM.mjs";
+export {};

package/dist/methods.cjs

@@ -0,0 +1,21 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/methods.ts
+/** The HTTP methods a client offers as calls: `api.get(…)`, `api.post(…)`. */
+const CALL_METHODS = [
+	"get",
+	"post",
+	"put",
+	"patch",
+	"delete",
+	"options"
+];
+/** The method calls for a client, each delegating to `api('METHOD /route', …)`. */
+function methodCalls(fn) {
+	const call = (method) => (route, config) => fn(`${method.toUpperCase()} ${route}`, config);
+	return Object.fromEntries(CALL_METHODS.map((method) => [method, call(method)]));
+}
+//#endregion
+exports.CALL_METHODS = CALL_METHODS;
+exports.methodCalls = methodCalls;
+
+//# sourceMappingURL=methods.cjs.map

package/dist/methods.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.cjs","names":[],"sources":["../src/methods.ts"],"sourcesContent":["import type {\n\tExtractEndpointResponse,\n\tExtractMethod,\n\tFilteredRequestConfig,\n\tIsConfigRequired,\n\tTypedApiFunction,\n\tTypedEndpoint,\n} from './types';\n\n/** The HTTP methods a client offers as calls: `api.get(…)`, `api.post(…)`. */\nexport const CALL_METHODS = [\n\t'get',\n\t'post',\n\t'put',\n\t'patch',\n\t'delete',\n\t'options',\n] as const;\n\nexport type CallMethod = (typeof CALL_METHODS)[number];\n\n/**\n * The routes that answer `M` — only routes with a `POST` appear in `api.post`,\n * so a route that exists under another method is a type error, not a 405.\n */\nexport type RoutesFor<Paths, M extends CallMethod> = {\n\t[R in keyof Paths]: M extends ExtractMethod<Paths, R> ? R : never;\n}[keyof Paths] &\n\tstring;\n\n/**\n * One method's call: `api.post('/users', { body })`.\n *\n * The second argument has only the keys the endpoint declares, and is required\n * exactly when something in it is — the same rule as `api('POST /users', …)`,\n * which this is sugar over.\n */\nexport type MethodCall<Paths, M extends CallMethod> = <\n\tR extends RoutesFor<Paths, M>,\n>(\n\troute: R,\n\t...args: `${Uppercase<M>} ${R}` extends TypedEndpoint<Paths>\n\t\t? IsConfigRequired<Paths, `${Uppercase<M>} ${R}`> extends true\n\t\t\t? [config: FilteredRequestConfig<Paths, `${Uppercase<M>} ${R}`>]\n\t\t\t: [config?: FilteredRequestConfig<Paths, `${Uppercase<M>} ${R}`>]\n\t\t: never\n) => Promise<ExtractEndpointResponse<Paths, `${Uppercase<M>} ${R}`>>;\n\nexport type MethodCalls<Paths> = {\n\t[M in CallMethod]: MethodCall<Paths, M>;\n};\n\n/** The method calls for a client, each delegating to `api('METHOD /route', …)`. */\nexport function methodCalls<Paths>(\n\tfn: TypedApiFunction<Paths>,\n): MethodCalls<Paths> {\n\tconst call =\n\t\t(method: CallMethod) =>\n\t\t(route: string, config?: unknown): Promise<unknown> =>\n\t\t\t(fn as (endpoint: string, config?: unknown) => Promise<unknown>)(\n\t\t\t\t`${method.toUpperCase()} ${route}`,\n\t\t\t\tconfig,\n\t\t\t);\n\n\treturn Object.fromEntries(\n\t\tCALL_METHODS.map((method) => [method, call(method)]),\n\t) as unknown as MethodCalls<Paths>;\n}\n"],"mappings":";;;AAUA,MAAa,eAAe;CAC3B;CACA;CACA;CACA;CACA;CACA;AACD;;AAoCA,SAAgB,YACf,IACqB;CACrB,MAAM,QACJ,YACA,OAAe,WACd,GACA,GAAG,OAAO,YAAY,EAAE,GAAG,SAC3B,MACD;CAEF,OAAO,OAAO,YACb,aAAa,KAAK,WAAW,CAAC,QAAQ,KAAK,MAAM,CAAC,CAAC,CACpD;AACD"}

package/dist/methods.d.cts

@@ -0,0 +1,23 @@
+import { ExtractEndpointResponse, ExtractMethod, FilteredRequestConfig, IsConfigRequired, TypedApiFunction, TypedEndpoint } from "./types.cjs";
+//#region src/methods.d.ts
+/** The HTTP methods a client offers as calls: `api.get(…)`, `api.post(…)`. */
+export declare const CALL_METHODS: readonly ['get', 'post', 'put', 'patch', 'delete', 'options'];
+export type CallMethod = (typeof CALL_METHODS)[number];
+/**
+ * The routes that answer `M` — only routes with a `POST` appear in `api.post`,
+ * so a route that exists under another method is a type error, not a 405.
+ */
+export type RoutesFor<Paths, M extends CallMethod> = { [R in keyof Paths]: M extends ExtractMethod<Paths, R> ? R : never; }[keyof Paths] & string;
+/**
+ * One method's call: `api.post('/users', { body })`.
+ *
+ * The second argument has only the keys the endpoint declares, and is required
+ * exactly when something in it is — the same rule as `api('POST /users', …)`,
+ * which this is sugar over.
+ */
+export type MethodCall<Paths, M extends CallMethod> = <R extends RoutesFor<Paths, M>>(route: R, ...args: `${Uppercase<M>} ${R}` extends TypedEndpoint<Paths> ? IsConfigRequired<Paths, `${Uppercase<M>} ${R}`> extends true ? [config: FilteredRequestConfig<Paths, `${Uppercase<M>} ${R}`>] : [config?: FilteredRequestConfig<Paths, `${Uppercase<M>} ${R}`>] : never) => Promise<ExtractEndpointResponse<Paths, `${Uppercase<M>} ${R}`>>;
+export type MethodCalls<Paths> = { [M in CallMethod]: MethodCall<Paths, M>; };
+/** The method calls for a client, each delegating to `api('METHOD /route', …)`. */
+export declare function methodCalls<Paths>(fn: TypedApiFunction<Paths>): MethodCalls<Paths>;
+//#endregion
+//# sourceMappingURL=methods.d.cts.map

package/dist/methods.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.d.cts","names":[],"sources":["../src/methods.ts"],"mappings":";;;qBAUa;YASD,qBAAqB;;;;;YAMrB,UAAU,OAAO,UAAU,iBACrC,WAAW,QAAQ,UAAU,cAAc,OAAO,KAAK,mBACjD;;;;;;;;YAUI,WAAW,OAAO,UAAU,eACvC,UAAU,UAAU,OAAO,IAE3B,OAAO,MACJ,SAAS,UAAU,MAAM,YAAY,cAAc,SACnD,iBAAiB,UAAU,UAAU,MAAM,qBACzC,QAAQ,sBAAsB,UAAU,UAAU,MAAM,SACxD,SAAS,sBAAsB,UAAU,UAAU,MAAM,kBAE1D,QAAQ,wBAAwB,UAAU,UAAU,MAAM;YAEnD,YAAY,YACtB,KAAK,aAAa,WAAW,OAAO;;wBAItB,YAAY,OAC3B,IAAI,iBAAiB,SACnB,YAAY"}

package/dist/methods.d.mts

@@ -0,0 +1,23 @@
+import { ExtractEndpointResponse, ExtractMethod, FilteredRequestConfig, IsConfigRequired, TypedApiFunction, TypedEndpoint } from "./types.mjs";
+//#region src/methods.d.ts
+/** The HTTP methods a client offers as calls: `api.get(…)`, `api.post(…)`. */
+export declare const CALL_METHODS: readonly ['get', 'post', 'put', 'patch', 'delete', 'options'];
+export type CallMethod = (typeof CALL_METHODS)[number];
+/**
+ * The routes that answer `M` — only routes with a `POST` appear in `api.post`,
+ * so a route that exists under another method is a type error, not a 405.
+ */
+export type RoutesFor<Paths, M extends CallMethod> = { [R in keyof Paths]: M extends ExtractMethod<Paths, R> ? R : never; }[keyof Paths] & string;
+/**
+ * One method's call: `api.post('/users', { body })`.
+ *
+ * The second argument has only the keys the endpoint declares, and is required
+ * exactly when something in it is — the same rule as `api('POST /users', …)`,
+ * which this is sugar over.
+ */
+export type MethodCall<Paths, M extends CallMethod> = <R extends RoutesFor<Paths, M>>(route: R, ...args: `${Uppercase<M>} ${R}` extends TypedEndpoint<Paths> ? IsConfigRequired<Paths, `${Uppercase<M>} ${R}`> extends true ? [config: FilteredRequestConfig<Paths, `${Uppercase<M>} ${R}`>] : [config?: FilteredRequestConfig<Paths, `${Uppercase<M>} ${R}`>] : never) => Promise<ExtractEndpointResponse<Paths, `${Uppercase<M>} ${R}`>>;
+export type MethodCalls<Paths> = { [M in CallMethod]: MethodCall<Paths, M>; };
+/** The method calls for a client, each delegating to `api('METHOD /route', …)`. */
+export declare function methodCalls<Paths>(fn: TypedApiFunction<Paths>): MethodCalls<Paths>;
+//#endregion
+//# sourceMappingURL=methods.d.mts.map

package/dist/methods.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.d.mts","names":[],"sources":["../src/methods.ts"],"mappings":";;;qBAUa;YASD,qBAAqB;;;;;YAMrB,UAAU,OAAO,UAAU,iBACrC,WAAW,QAAQ,UAAU,cAAc,OAAO,KAAK,mBACjD;;;;;;;;YAUI,WAAW,OAAO,UAAU,eACvC,UAAU,UAAU,OAAO,IAE3B,OAAO,MACJ,SAAS,UAAU,MAAM,YAAY,cAAc,SACnD,iBAAiB,UAAU,UAAU,MAAM,qBACzC,QAAQ,sBAAsB,UAAU,UAAU,MAAM,SACxD,SAAS,sBAAsB,UAAU,UAAU,MAAM,kBAE1D,QAAQ,wBAAwB,UAAU,UAAU,MAAM;YAEnD,YAAY,YACtB,KAAK,aAAa,WAAW,OAAO;;wBAItB,YAAY,OAC3B,IAAI,iBAAiB,SACnB,YAAY"}

package/dist/methods.mjs

@@ -0,0 +1,19 @@
+//#region src/methods.ts
+/** The HTTP methods a client offers as calls: `api.get(…)`, `api.post(…)`. */
+const CALL_METHODS = [
+	"get",
+	"post",
+	"put",
+	"patch",
+	"delete",
+	"options"
+];
+/** The method calls for a client, each delegating to `api('METHOD /route', …)`. */
+function methodCalls(fn) {
+	const call = (method) => (route, config) => fn(`${method.toUpperCase()} ${route}`, config);
+	return Object.fromEntries(CALL_METHODS.map((method) => [method, call(method)]));
+}
+//#endregion
+export { CALL_METHODS, methodCalls };
+
+//# sourceMappingURL=methods.mjs.map

package/dist/methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"methods.mjs","names":[],"sources":["../src/methods.ts"],"sourcesContent":["import type {\n\tExtractEndpointResponse,\n\tExtractMethod,\n\tFilteredRequestConfig,\n\tIsConfigRequired,\n\tTypedApiFunction,\n\tTypedEndpoint,\n} from './types';\n\n/** The HTTP methods a client offers as calls: `api.get(…)`, `api.post(…)`. */\nexport const CALL_METHODS = [\n\t'get',\n\t'post',\n\t'put',\n\t'patch',\n\t'delete',\n\t'options',\n] as const;\n\nexport type CallMethod = (typeof CALL_METHODS)[number];\n\n/**\n * The routes that answer `M` — only routes with a `POST` appear in `api.post`,\n * so a route that exists under another method is a type error, not a 405.\n */\nexport type RoutesFor<Paths, M extends CallMethod> = {\n\t[R in keyof Paths]: M extends ExtractMethod<Paths, R> ? R : never;\n}[keyof Paths] &\n\tstring;\n\n/**\n * One method's call: `api.post('/users', { body })`.\n *\n * The second argument has only the keys the endpoint declares, and is required\n * exactly when something in it is — the same rule as `api('POST /users', …)`,\n * which this is sugar over.\n */\nexport type MethodCall<Paths, M extends CallMethod> = <\n\tR extends RoutesFor<Paths, M>,\n>(\n\troute: R,\n\t...args: `${Uppercase<M>} ${R}` extends TypedEndpoint<Paths>\n\t\t? IsConfigRequired<Paths, `${Uppercase<M>} ${R}`> extends true\n\t\t\t? [config: FilteredRequestConfig<Paths, `${Uppercase<M>} ${R}`>]\n\t\t\t: [config?: FilteredRequestConfig<Paths, `${Uppercase<M>} ${R}`>]\n\t\t: never\n) => Promise<ExtractEndpointResponse<Paths, `${Uppercase<M>} ${R}`>>;\n\nexport type MethodCalls<Paths> = {\n\t[M in CallMethod]: MethodCall<Paths, M>;\n};\n\n/** The method calls for a client, each delegating to `api('METHOD /route', …)`. */\nexport function methodCalls<Paths>(\n\tfn: TypedApiFunction<Paths>,\n): MethodCalls<Paths> {\n\tconst call =\n\t\t(method: CallMethod) =>\n\t\t(route: string, config?: unknown): Promise<unknown> =>\n\t\t\t(fn as (endpoint: string, config?: unknown) => Promise<unknown>)(\n\t\t\t\t`${method.toUpperCase()} ${route}`,\n\t\t\t\tconfig,\n\t\t\t);\n\n\treturn Object.fromEntries(\n\t\tCALL_METHODS.map((method) => [method, call(method)]),\n\t) as unknown as MethodCalls<Paths>;\n}\n"],"mappings":";;AAUA,MAAa,eAAe;CAC3B;CACA;CACA;CACA;CACA;CACA;AACD;;AAoCA,SAAgB,YACf,IACqB;CACrB,MAAM,QACJ,YACA,OAAe,WACd,GACA,GAAG,OAAO,YAAY,EAAE,GAAG,SAC3B,MACD;CAEF,OAAO,OAAO,YACb,aAAa,KAAK,WAAW,CAAC,QAAQ,KAAK,MAAM,CAAC,CAAC,CACpD;AACD"}