enlace 0.0.0-alpha.2 → 0.0.0-alpha.4

package/dist/index.d.mts

@@ -1,5 +1,106 @@
-import { E as EnlaceOptions, F as FetchExecutor, R as RequestOptions, H as HttpMethod, a as EnlaceResponse, W as WildcardClient, b as EnlaceClient } from './types-B-6qIYag.mjs';
-export { c as Endpoint, M as MethodDefinition, S as SchemaMethod } from './types-B-6qIYag.mjs';
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+type SchemaMethod = "$get" | "$post" | "$put" | "$patch" | "$delete";
+type EnlaceResponse<TData, TError> = {
+    ok: true;
+    status: number;
+    data: TData;
+    error?: never;
+} | {
+    ok: false;
+    status: number;
+    data?: never;
+    error: TError;
+};
+type EnlaceOptions = Omit<RequestInit, "method" | "body">;
+type FetchExecutor<TOptions = EnlaceOptions, TRequestOptions = RequestOptions<unknown>> = <TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: TOptions, requestOptions?: TRequestOptions) => Promise<EnlaceResponse<TData, TError>>;
+type RequestOptions<TBody = never> = {
+    body?: TBody;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: HeadersInit;
+    cache?: RequestCache;
+};
+type MethodDefinition = {
+    data: unknown;
+    error: unknown;
+    body?: unknown;
+};
+/**
+ * Helper to define an endpoint with proper typing.
+ * Provides cleaner syntax than writing { data, error, body } manually.
+ *
+ * @example
+ * type MyApi = {
+ *   posts: {
+ *     $get: Endpoint<Post[], ApiError>;
+ *     $post: Endpoint<Post, ApiError, CreatePost>;  // with body
+ *     _: {
+ *       $get: Endpoint<Post, NotFoundError>;
+ *     };
+ *   };
+ * };
+ */
+type Endpoint<TData, TError, TBody = never> = [TBody] extends [never] ? {
+    data: TData;
+    error: TError;
+} : {
+    data: TData;
+    error: TError;
+    body: TBody;
+};
+type ExtractMethodDef<TSchema, TMethod extends SchemaMethod> = TSchema extends {
+    [K in TMethod]: infer M;
+} ? M extends MethodDefinition ? M : never : never;
+type ExtractData<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    data: infer D;
+} ? D : never;
+type ExtractError<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    error: infer E;
+} ? E : never;
+type ExtractBody<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    body: infer B;
+} ? B : never;
+type HasMethod<TSchema, TMethod extends SchemaMethod> = TSchema extends {
+    [K in TMethod]: MethodDefinition;
+} ? true : false;
+type MethodFn<TSchema, TMethod extends SchemaMethod, TRequestOptionsBase = object> = HasMethod<TSchema, TMethod> extends true ? ExtractBody<TSchema, TMethod> extends never ? (options?: RequestOptions<never> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : (options: RequestOptions<ExtractBody<TSchema, TMethod>> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : never;
+type IsSpecialKey<K> = K extends SchemaMethod | "_" ? true : false;
+type StaticPathKeys<TSchema> = {
+    [K in keyof TSchema as IsSpecialKey<K> extends true ? never : K extends string ? K : never]: TSchema[K];
+};
+type ExtractDynamicSchema<TSchema> = TSchema extends {
+    _: infer D;
+} ? D : never;
+type MethodOrPath<TSchema, TMethodName extends string, TSchemaMethod extends SchemaMethod, TRequestOptionsBase = object> = TMethodName extends keyof TSchema ? EnlaceClient<TSchema[TMethodName], TRequestOptionsBase> : MethodFn<TSchema, TSchemaMethod, TRequestOptionsBase>;
+type HttpMethods<TSchema, TRequestOptionsBase = object> = {
+    get: MethodOrPath<TSchema, "get", "$get", TRequestOptionsBase>;
+    post: MethodOrPath<TSchema, "post", "$post", TRequestOptionsBase>;
+    put: MethodOrPath<TSchema, "put", "$put", TRequestOptionsBase>;
+    patch: MethodOrPath<TSchema, "patch", "$patch", TRequestOptionsBase>;
+    delete: MethodOrPath<TSchema, "delete", "$delete", TRequestOptionsBase>;
+};
+type DynamicAccess<TSchema, TRequestOptionsBase = object> = ExtractDynamicSchema<TSchema> extends never ? object : {
+    [key: string]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+    [key: number]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+};
+type MethodNameKeys = "get" | "post" | "put" | "patch" | "delete";
+type EnlaceClient<TSchema, TRequestOptionsBase = object> = HttpMethods<TSchema, TRequestOptionsBase> & DynamicAccess<TSchema, TRequestOptionsBase> & {
+    [K in keyof StaticPathKeys<TSchema> as K extends MethodNameKeys ? never : K]: EnlaceClient<TSchema[K], TRequestOptionsBase>;
+};
+type WildcardMethodFn<TRequestOptionsBase = object> = (options?: RequestOptions<unknown> & TRequestOptionsBase) => Promise<EnlaceResponse<unknown, unknown>>;
+/**
+ * Wildcard client type - allows any path access when no schema is provided.
+ * All methods are available at every level and return unknown types.
+ */
+type WildcardClient<TRequestOptionsBase = object> = {
+    get: WildcardMethodFn<TRequestOptionsBase>;
+    post: WildcardMethodFn<TRequestOptionsBase>;
+    put: WildcardMethodFn<TRequestOptionsBase>;
+    patch: WildcardMethodFn<TRequestOptionsBase>;
+    delete: WildcardMethodFn<TRequestOptionsBase>;
+} & {
+    [key: string]: WildcardClient<TRequestOptionsBase>;
+    [key: number]: WildcardClient<TRequestOptionsBase>;
+};
 
 declare function createProxyHandler<TSchema extends object, TOptions = EnlaceOptions>(baseUrl: string, defaultOptions: TOptions, path?: string[], fetchExecutor?: FetchExecutor<TOptions, RequestOptions<unknown>>): TSchema;
 
@@ -17,4 +118,4 @@ declare function executeFetch<TData, TError>(baseUrl: string, path: string[], me
  */
 declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions): unknown extends TSchema ? WildcardClient : EnlaceClient<TSchema>;
 
-export { EnlaceClient, EnlaceOptions, EnlaceResponse, FetchExecutor, HttpMethod, RequestOptions, WildcardClient, createEnlace, createProxyHandler, executeFetch };
+export { type Endpoint, type EnlaceClient, type EnlaceOptions, type EnlaceResponse, type FetchExecutor, type HttpMethod, type MethodDefinition, type RequestOptions, type SchemaMethod, type WildcardClient, createEnlace, createProxyHandler, executeFetch };

package/dist/index.d.ts

@@ -1,5 +1,106 @@
-import { E as EnlaceOptions, F as FetchExecutor, R as RequestOptions, H as HttpMethod, a as EnlaceResponse, W as WildcardClient, b as EnlaceClient } from './types-B-6qIYag.js';
-export { c as Endpoint, M as MethodDefinition, S as SchemaMethod } from './types-B-6qIYag.js';
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+type SchemaMethod = "$get" | "$post" | "$put" | "$patch" | "$delete";
+type EnlaceResponse<TData, TError> = {
+    ok: true;
+    status: number;
+    data: TData;
+    error?: never;
+} | {
+    ok: false;
+    status: number;
+    data?: never;
+    error: TError;
+};
+type EnlaceOptions = Omit<RequestInit, "method" | "body">;
+type FetchExecutor<TOptions = EnlaceOptions, TRequestOptions = RequestOptions<unknown>> = <TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: TOptions, requestOptions?: TRequestOptions) => Promise<EnlaceResponse<TData, TError>>;
+type RequestOptions<TBody = never> = {
+    body?: TBody;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: HeadersInit;
+    cache?: RequestCache;
+};
+type MethodDefinition = {
+    data: unknown;
+    error: unknown;
+    body?: unknown;
+};
+/**
+ * Helper to define an endpoint with proper typing.
+ * Provides cleaner syntax than writing { data, error, body } manually.
+ *
+ * @example
+ * type MyApi = {
+ *   posts: {
+ *     $get: Endpoint<Post[], ApiError>;
+ *     $post: Endpoint<Post, ApiError, CreatePost>;  // with body
+ *     _: {
+ *       $get: Endpoint<Post, NotFoundError>;
+ *     };
+ *   };
+ * };
+ */
+type Endpoint<TData, TError, TBody = never> = [TBody] extends [never] ? {
+    data: TData;
+    error: TError;
+} : {
+    data: TData;
+    error: TError;
+    body: TBody;
+};
+type ExtractMethodDef<TSchema, TMethod extends SchemaMethod> = TSchema extends {
+    [K in TMethod]: infer M;
+} ? M extends MethodDefinition ? M : never : never;
+type ExtractData<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    data: infer D;
+} ? D : never;
+type ExtractError<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    error: infer E;
+} ? E : never;
+type ExtractBody<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    body: infer B;
+} ? B : never;
+type HasMethod<TSchema, TMethod extends SchemaMethod> = TSchema extends {
+    [K in TMethod]: MethodDefinition;
+} ? true : false;
+type MethodFn<TSchema, TMethod extends SchemaMethod, TRequestOptionsBase = object> = HasMethod<TSchema, TMethod> extends true ? ExtractBody<TSchema, TMethod> extends never ? (options?: RequestOptions<never> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : (options: RequestOptions<ExtractBody<TSchema, TMethod>> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : never;
+type IsSpecialKey<K> = K extends SchemaMethod | "_" ? true : false;
+type StaticPathKeys<TSchema> = {
+    [K in keyof TSchema as IsSpecialKey<K> extends true ? never : K extends string ? K : never]: TSchema[K];
+};
+type ExtractDynamicSchema<TSchema> = TSchema extends {
+    _: infer D;
+} ? D : never;
+type MethodOrPath<TSchema, TMethodName extends string, TSchemaMethod extends SchemaMethod, TRequestOptionsBase = object> = TMethodName extends keyof TSchema ? EnlaceClient<TSchema[TMethodName], TRequestOptionsBase> : MethodFn<TSchema, TSchemaMethod, TRequestOptionsBase>;
+type HttpMethods<TSchema, TRequestOptionsBase = object> = {
+    get: MethodOrPath<TSchema, "get", "$get", TRequestOptionsBase>;
+    post: MethodOrPath<TSchema, "post", "$post", TRequestOptionsBase>;
+    put: MethodOrPath<TSchema, "put", "$put", TRequestOptionsBase>;
+    patch: MethodOrPath<TSchema, "patch", "$patch", TRequestOptionsBase>;
+    delete: MethodOrPath<TSchema, "delete", "$delete", TRequestOptionsBase>;
+};
+type DynamicAccess<TSchema, TRequestOptionsBase = object> = ExtractDynamicSchema<TSchema> extends never ? object : {
+    [key: string]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+    [key: number]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+};
+type MethodNameKeys = "get" | "post" | "put" | "patch" | "delete";
+type EnlaceClient<TSchema, TRequestOptionsBase = object> = HttpMethods<TSchema, TRequestOptionsBase> & DynamicAccess<TSchema, TRequestOptionsBase> & {
+    [K in keyof StaticPathKeys<TSchema> as K extends MethodNameKeys ? never : K]: EnlaceClient<TSchema[K], TRequestOptionsBase>;
+};
+type WildcardMethodFn<TRequestOptionsBase = object> = (options?: RequestOptions<unknown> & TRequestOptionsBase) => Promise<EnlaceResponse<unknown, unknown>>;
+/**
+ * Wildcard client type - allows any path access when no schema is provided.
+ * All methods are available at every level and return unknown types.
+ */
+type WildcardClient<TRequestOptionsBase = object> = {
+    get: WildcardMethodFn<TRequestOptionsBase>;
+    post: WildcardMethodFn<TRequestOptionsBase>;
+    put: WildcardMethodFn<TRequestOptionsBase>;
+    patch: WildcardMethodFn<TRequestOptionsBase>;
+    delete: WildcardMethodFn<TRequestOptionsBase>;
+} & {
+    [key: string]: WildcardClient<TRequestOptionsBase>;
+    [key: number]: WildcardClient<TRequestOptionsBase>;
+};
 
 declare function createProxyHandler<TSchema extends object, TOptions = EnlaceOptions>(baseUrl: string, defaultOptions: TOptions, path?: string[], fetchExecutor?: FetchExecutor<TOptions, RequestOptions<unknown>>): TSchema;
 
@@ -17,4 +118,4 @@ declare function executeFetch<TData, TError>(baseUrl: string, path: string[], me
  */
 declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions): unknown extends TSchema ? WildcardClient : EnlaceClient<TSchema>;
 
-export { EnlaceClient, EnlaceOptions, EnlaceResponse, FetchExecutor, HttpMethod, RequestOptions, WildcardClient, createEnlace, createProxyHandler, executeFetch };
+export { type Endpoint, type EnlaceClient, type EnlaceOptions, type EnlaceResponse, type FetchExecutor, type HttpMethod, type MethodDefinition, type RequestOptions, type SchemaMethod, type WildcardClient, createEnlace, createProxyHandler, executeFetch };

package/dist/index.js

@@ -28,18 +28,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
   createEnlace: () => createEnlace,
   createProxyHandler: () => createProxyHandler,
   executeFetch: () => executeFetch
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/utils/buildUrl.ts
 var import_query_string = __toESM(require("query-string"));
 function buildUrl(baseUrl, path, query) {
-  const url = new URL(path.join("/"), baseUrl);
+  const normalizedBase = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const url = new URL(path.join("/"), normalizedBase);
   if (query) {
     url.search = import_query_string.default.stringify(query, { skipNull: true, skipEmptyString: true });
   }

package/dist/index.mjs

@@ -1,7 +1,97 @@
-import {
-  createProxyHandler,
-  executeFetch
-} from "./chunk-PNORT7RX.mjs";
+// src/utils/buildUrl.ts
+import qs from "query-string";
+function buildUrl(baseUrl, path, query) {
+  const normalizedBase = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const url = new URL(path.join("/"), normalizedBase);
+  if (query) {
+    url.search = qs.stringify(query, { skipNull: true, skipEmptyString: true });
+  }
+  return url.toString();
+}
+
+// src/utils/isJsonBody.ts
+function isJsonBody(body) {
+  if (body === null || body === void 0) return false;
+  if (body instanceof FormData) return false;
+  if (body instanceof Blob) return false;
+  if (body instanceof ArrayBuffer) return false;
+  if (body instanceof URLSearchParams) return false;
+  if (body instanceof ReadableStream) return false;
+  if (typeof body === "string") return false;
+  return typeof body === "object";
+}
+
+// src/utils/mergeHeaders.ts
+function mergeHeaders(defaultHeaders, requestHeaders) {
+  if (!defaultHeaders && !requestHeaders) return void 0;
+  if (!defaultHeaders) return requestHeaders;
+  if (!requestHeaders) return defaultHeaders;
+  return {
+    ...Object.fromEntries(new Headers(defaultHeaders)),
+    ...Object.fromEntries(new Headers(requestHeaders))
+  };
+}
+
+// src/core/fetch.ts
+async function executeFetch(baseUrl, path, method, defaultOptions, requestOptions) {
+  const url = buildUrl(baseUrl, path, requestOptions?.query);
+  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
+  const fetchOptions = {
+    ...defaultOptions,
+    method
+  };
+  if (headers) {
+    fetchOptions.headers = headers;
+  }
+  if (requestOptions?.body !== void 0) {
+    if (isJsonBody(requestOptions.body)) {
+      fetchOptions.body = JSON.stringify(requestOptions.body);
+      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
+      if (headers) {
+        fetchOptions.headers = headers;
+      }
+    } else {
+      fetchOptions.body = requestOptions.body;
+    }
+  }
+  const response = await fetch(url, fetchOptions);
+  const contentType = response.headers.get("content-type");
+  const isJson = contentType?.includes("application/json");
+  if (response.ok) {
+    return {
+      ok: true,
+      status: response.status,
+      data: isJson ? await response.json() : response
+    };
+  }
+  return {
+    ok: false,
+    status: response.status,
+    error: isJson ? await response.json() : response
+  };
+}
+
+// src/core/proxy.ts
+var HTTP_METHODS = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  patch: "PATCH",
+  delete: "DELETE"
+};
+function createProxyHandler(baseUrl, defaultOptions, path = [], fetchExecutor = executeFetch) {
+  const handler = {
+    get(_target, prop) {
+      if (typeof prop === "symbol") return void 0;
+      const method = HTTP_METHODS[prop];
+      if (method) {
+        return (options) => fetchExecutor(baseUrl, path, method, defaultOptions, options);
+      }
+      return createProxyHandler(baseUrl, defaultOptions, [...path, prop], fetchExecutor);
+    }
+  };
+  return new Proxy({}, handler);
+}
 
 // src/core/index.ts
 function createEnlace(baseUrl, defaultOptions = {}) {

package/dist/next/index.d.mts

@@ -1,18 +1,121 @@
-import { R as RequestOptions, W as WildcardClient, b as EnlaceClient } from '../types-B-6qIYag.mjs';
-export { c as Endpoint, E as EnlaceOptions, a as EnlaceResponse, F as FetchExecutor, H as HttpMethod, M as MethodDefinition, S as SchemaMethod } from '../types-B-6qIYag.mjs';
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+type SchemaMethod = "$get" | "$post" | "$put" | "$patch" | "$delete";
+type EnlaceResponse<TData, TError> = {
+    ok: true;
+    status: number;
+    data: TData;
+    error?: never;
+} | {
+    ok: false;
+    status: number;
+    data?: never;
+    error: TError;
+};
+type EnlaceOptions = Omit<RequestInit, "method" | "body">;
+type FetchExecutor<TOptions = EnlaceOptions, TRequestOptions = RequestOptions<unknown>> = <TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: TOptions, requestOptions?: TRequestOptions) => Promise<EnlaceResponse<TData, TError>>;
+type RequestOptions<TBody = never> = {
+    body?: TBody;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: HeadersInit;
+    cache?: RequestCache;
+};
+type MethodDefinition = {
+    data: unknown;
+    error: unknown;
+    body?: unknown;
+};
+/**
+ * Helper to define an endpoint with proper typing.
+ * Provides cleaner syntax than writing { data, error, body } manually.
+ *
+ * @example
+ * type MyApi = {
+ *   posts: {
+ *     $get: Endpoint<Post[], ApiError>;
+ *     $post: Endpoint<Post, ApiError, CreatePost>;  // with body
+ *     _: {
+ *       $get: Endpoint<Post, NotFoundError>;
+ *     };
+ *   };
+ * };
+ */
+type Endpoint<TData, TError, TBody = never> = [TBody] extends [never] ? {
+    data: TData;
+    error: TError;
+} : {
+    data: TData;
+    error: TError;
+    body: TBody;
+};
+type ExtractMethodDef<TSchema, TMethod extends SchemaMethod> = TSchema extends {
+    [K in TMethod]: infer M;
+} ? M extends MethodDefinition ? M : never : never;
+type ExtractData<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    data: infer D;
+} ? D : never;
+type ExtractError<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    error: infer E;
+} ? E : never;
+type ExtractBody<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    body: infer B;
+} ? B : never;
+type HasMethod<TSchema, TMethod extends SchemaMethod> = TSchema extends {
+    [K in TMethod]: MethodDefinition;
+} ? true : false;
+type MethodFn<TSchema, TMethod extends SchemaMethod, TRequestOptionsBase = object> = HasMethod<TSchema, TMethod> extends true ? ExtractBody<TSchema, TMethod> extends never ? (options?: RequestOptions<never> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : (options: RequestOptions<ExtractBody<TSchema, TMethod>> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : never;
+type IsSpecialKey<K> = K extends SchemaMethod | "_" ? true : false;
+type StaticPathKeys<TSchema> = {
+    [K in keyof TSchema as IsSpecialKey<K> extends true ? never : K extends string ? K : never]: TSchema[K];
+};
+type ExtractDynamicSchema<TSchema> = TSchema extends {
+    _: infer D;
+} ? D : never;
+type MethodOrPath<TSchema, TMethodName extends string, TSchemaMethod extends SchemaMethod, TRequestOptionsBase = object> = TMethodName extends keyof TSchema ? EnlaceClient<TSchema[TMethodName], TRequestOptionsBase> : MethodFn<TSchema, TSchemaMethod, TRequestOptionsBase>;
+type HttpMethods<TSchema, TRequestOptionsBase = object> = {
+    get: MethodOrPath<TSchema, "get", "$get", TRequestOptionsBase>;
+    post: MethodOrPath<TSchema, "post", "$post", TRequestOptionsBase>;
+    put: MethodOrPath<TSchema, "put", "$put", TRequestOptionsBase>;
+    patch: MethodOrPath<TSchema, "patch", "$patch", TRequestOptionsBase>;
+    delete: MethodOrPath<TSchema, "delete", "$delete", TRequestOptionsBase>;
+};
+type DynamicAccess<TSchema, TRequestOptionsBase = object> = ExtractDynamicSchema<TSchema> extends never ? object : {
+    [key: string]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+    [key: number]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+};
+type MethodNameKeys = "get" | "post" | "put" | "patch" | "delete";
+type EnlaceClient<TSchema, TRequestOptionsBase = object> = HttpMethods<TSchema, TRequestOptionsBase> & DynamicAccess<TSchema, TRequestOptionsBase> & {
+    [K in keyof StaticPathKeys<TSchema> as K extends MethodNameKeys ? never : K]: EnlaceClient<TSchema[K], TRequestOptionsBase>;
+};
+type WildcardMethodFn<TRequestOptionsBase = object> = (options?: RequestOptions<unknown> & TRequestOptionsBase) => Promise<EnlaceResponse<unknown, unknown>>;
+/**
+ * Wildcard client type - allows any path access when no schema is provided.
+ * All methods are available at every level and return unknown types.
+ */
+type WildcardClient<TRequestOptionsBase = object> = {
+    get: WildcardMethodFn<TRequestOptionsBase>;
+    post: WildcardMethodFn<TRequestOptionsBase>;
+    put: WildcardMethodFn<TRequestOptionsBase>;
+    patch: WildcardMethodFn<TRequestOptionsBase>;
+    delete: WildcardMethodFn<TRequestOptionsBase>;
+} & {
+    [key: string]: WildcardClient<TRequestOptionsBase>;
+    [key: number]: WildcardClient<TRequestOptionsBase>;
+};
 
 type NextFetchOptions = {
     revalidate?: number | false;
     tags?: string[];
 };
-type NextEnlaceOptions = Omit<RequestInit, 'method' | 'body'> & {
-    next?: NextFetchOptions;
+type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
+type NextEnlaceOptions = EnlaceOptions & {
+    revalidate?: RevalidateHandler;
 };
-type NextRequestOptions<TBody = never> = RequestOptions<TBody> & {
-    cache?: 'force-cache' | 'no-store';
+type NextRequestOptionsBase = {
     next?: NextFetchOptions;
+    revalidateTags?: string[];
+    revalidatePaths?: string[];
 };
 
-declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: NextEnlaceOptions): unknown extends TSchema ? WildcardClient : EnlaceClient<TSchema>;
+declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: NextEnlaceOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
 
-export { EnlaceClient, type NextEnlaceOptions, type NextFetchOptions, type NextRequestOptions, RequestOptions, WildcardClient, createEnlace };
+export { type Endpoint, type EnlaceClient, type EnlaceOptions, type EnlaceResponse, type FetchExecutor, type HttpMethod, type MethodDefinition, type NextEnlaceOptions, type NextFetchOptions, type NextRequestOptionsBase, type RequestOptions, type RevalidateHandler, type SchemaMethod, type WildcardClient, createEnlace };

package/dist/next/index.d.ts

@@ -1,18 +1,121 @@
-import { R as RequestOptions, W as WildcardClient, b as EnlaceClient } from '../types-B-6qIYag.js';
-export { c as Endpoint, E as EnlaceOptions, a as EnlaceResponse, F as FetchExecutor, H as HttpMethod, M as MethodDefinition, S as SchemaMethod } from '../types-B-6qIYag.js';
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+type SchemaMethod = "$get" | "$post" | "$put" | "$patch" | "$delete";
+type EnlaceResponse<TData, TError> = {
+    ok: true;
+    status: number;
+    data: TData;
+    error?: never;
+} | {
+    ok: false;
+    status: number;
+    data?: never;
+    error: TError;
+};
+type EnlaceOptions = Omit<RequestInit, "method" | "body">;
+type FetchExecutor<TOptions = EnlaceOptions, TRequestOptions = RequestOptions<unknown>> = <TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: TOptions, requestOptions?: TRequestOptions) => Promise<EnlaceResponse<TData, TError>>;
+type RequestOptions<TBody = never> = {
+    body?: TBody;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: HeadersInit;
+    cache?: RequestCache;
+};
+type MethodDefinition = {
+    data: unknown;
+    error: unknown;
+    body?: unknown;
+};
+/**
+ * Helper to define an endpoint with proper typing.
+ * Provides cleaner syntax than writing { data, error, body } manually.
+ *
+ * @example
+ * type MyApi = {
+ *   posts: {
+ *     $get: Endpoint<Post[], ApiError>;
+ *     $post: Endpoint<Post, ApiError, CreatePost>;  // with body
+ *     _: {
+ *       $get: Endpoint<Post, NotFoundError>;
+ *     };
+ *   };
+ * };
+ */
+type Endpoint<TData, TError, TBody = never> = [TBody] extends [never] ? {
+    data: TData;
+    error: TError;
+} : {
+    data: TData;
+    error: TError;
+    body: TBody;
+};
+type ExtractMethodDef<TSchema, TMethod extends SchemaMethod> = TSchema extends {
+    [K in TMethod]: infer M;
+} ? M extends MethodDefinition ? M : never : never;
+type ExtractData<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    data: infer D;
+} ? D : never;
+type ExtractError<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    error: infer E;
+} ? E : never;
+type ExtractBody<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
+    body: infer B;
+} ? B : never;
+type HasMethod<TSchema, TMethod extends SchemaMethod> = TSchema extends {
+    [K in TMethod]: MethodDefinition;
+} ? true : false;
+type MethodFn<TSchema, TMethod extends SchemaMethod, TRequestOptionsBase = object> = HasMethod<TSchema, TMethod> extends true ? ExtractBody<TSchema, TMethod> extends never ? (options?: RequestOptions<never> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : (options: RequestOptions<ExtractBody<TSchema, TMethod>> & TRequestOptionsBase) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : never;
+type IsSpecialKey<K> = K extends SchemaMethod | "_" ? true : false;
+type StaticPathKeys<TSchema> = {
+    [K in keyof TSchema as IsSpecialKey<K> extends true ? never : K extends string ? K : never]: TSchema[K];
+};
+type ExtractDynamicSchema<TSchema> = TSchema extends {
+    _: infer D;
+} ? D : never;
+type MethodOrPath<TSchema, TMethodName extends string, TSchemaMethod extends SchemaMethod, TRequestOptionsBase = object> = TMethodName extends keyof TSchema ? EnlaceClient<TSchema[TMethodName], TRequestOptionsBase> : MethodFn<TSchema, TSchemaMethod, TRequestOptionsBase>;
+type HttpMethods<TSchema, TRequestOptionsBase = object> = {
+    get: MethodOrPath<TSchema, "get", "$get", TRequestOptionsBase>;
+    post: MethodOrPath<TSchema, "post", "$post", TRequestOptionsBase>;
+    put: MethodOrPath<TSchema, "put", "$put", TRequestOptionsBase>;
+    patch: MethodOrPath<TSchema, "patch", "$patch", TRequestOptionsBase>;
+    delete: MethodOrPath<TSchema, "delete", "$delete", TRequestOptionsBase>;
+};
+type DynamicAccess<TSchema, TRequestOptionsBase = object> = ExtractDynamicSchema<TSchema> extends never ? object : {
+    [key: string]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+    [key: number]: EnlaceClient<ExtractDynamicSchema<TSchema>, TRequestOptionsBase>;
+};
+type MethodNameKeys = "get" | "post" | "put" | "patch" | "delete";
+type EnlaceClient<TSchema, TRequestOptionsBase = object> = HttpMethods<TSchema, TRequestOptionsBase> & DynamicAccess<TSchema, TRequestOptionsBase> & {
+    [K in keyof StaticPathKeys<TSchema> as K extends MethodNameKeys ? never : K]: EnlaceClient<TSchema[K], TRequestOptionsBase>;
+};
+type WildcardMethodFn<TRequestOptionsBase = object> = (options?: RequestOptions<unknown> & TRequestOptionsBase) => Promise<EnlaceResponse<unknown, unknown>>;
+/**
+ * Wildcard client type - allows any path access when no schema is provided.
+ * All methods are available at every level and return unknown types.
+ */
+type WildcardClient<TRequestOptionsBase = object> = {
+    get: WildcardMethodFn<TRequestOptionsBase>;
+    post: WildcardMethodFn<TRequestOptionsBase>;
+    put: WildcardMethodFn<TRequestOptionsBase>;
+    patch: WildcardMethodFn<TRequestOptionsBase>;
+    delete: WildcardMethodFn<TRequestOptionsBase>;
+} & {
+    [key: string]: WildcardClient<TRequestOptionsBase>;
+    [key: number]: WildcardClient<TRequestOptionsBase>;
+};
 
 type NextFetchOptions = {
     revalidate?: number | false;
     tags?: string[];
 };
-type NextEnlaceOptions = Omit<RequestInit, 'method' | 'body'> & {
-    next?: NextFetchOptions;
+type RevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
+type NextEnlaceOptions = EnlaceOptions & {
+    revalidate?: RevalidateHandler;
 };
-type NextRequestOptions<TBody = never> = RequestOptions<TBody> & {
-    cache?: 'force-cache' | 'no-store';
+type NextRequestOptionsBase = {
     next?: NextFetchOptions;
+    revalidateTags?: string[];
+    revalidatePaths?: string[];
 };
 
-declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: NextEnlaceOptions): unknown extends TSchema ? WildcardClient : EnlaceClient<TSchema>;
+declare function createEnlace<TSchema = unknown>(baseUrl: string, defaultOptions?: NextEnlaceOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, NextRequestOptionsBase>;
 
-export { EnlaceClient, type NextEnlaceOptions, type NextFetchOptions, type NextRequestOptions, RequestOptions, WildcardClient, createEnlace };
+export { type Endpoint, type EnlaceClient, type EnlaceOptions, type EnlaceResponse, type FetchExecutor, type HttpMethod, type MethodDefinition, type NextEnlaceOptions, type NextFetchOptions, type NextRequestOptionsBase, type RequestOptions, type RevalidateHandler, type SchemaMethod, type WildcardClient, createEnlace };

package/dist/next/index.js

@@ -37,7 +37,8 @@ module.exports = __toCommonJS(next_exports);
 // src/utils/buildUrl.ts
 var import_query_string = __toESM(require("query-string"));
 function buildUrl(baseUrl, path, query) {
-  const url = new URL(path.join("/"), baseUrl);
+  const normalizedBase = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const url = new URL(path.join("/"), normalizedBase);
   if (query) {
     url.search = import_query_string.default.stringify(query, { skipNull: true, skipEmptyString: true });
   }
@@ -135,7 +136,7 @@ function generateTags(path) {
 async function executeNextFetch(baseUrl, path, method, defaultOptions, requestOptions) {
   const url = buildUrl(baseUrl, path, requestOptions?.query);
   let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
-  const nextOptions = requestOptions?.next ?? defaultOptions.next;
+  const nextOptions = requestOptions?.next;
   const tags = nextOptions?.tags ?? generateTags(path);
   const fetchOptions = {
     ...defaultOptions,
@@ -167,6 +168,10 @@ async function executeNextFetch(baseUrl, path, method, defaultOptions, requestOp
   const contentType = response.headers.get("content-type");
   const isJson = contentType?.includes("application/json");
   if (response.ok) {
+    const { revalidateTags = [], revalidatePaths = [] } = requestOptions ?? {};
+    if (revalidateTags.length || revalidatePaths.length) {
+      defaultOptions.revalidate?.(revalidateTags, revalidatePaths);
+    }
     return {
       ok: true,
       status: response.status,

package/dist/next/index.mjs

@@ -1,9 +1,97 @@
-import {
-  buildUrl,
-  createProxyHandler,
-  isJsonBody,
-  mergeHeaders
-} from "../chunk-PNORT7RX.mjs";
+// src/utils/buildUrl.ts
+import qs from "query-string";
+function buildUrl(baseUrl, path, query) {
+  const normalizedBase = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const url = new URL(path.join("/"), normalizedBase);
+  if (query) {
+    url.search = qs.stringify(query, { skipNull: true, skipEmptyString: true });
+  }
+  return url.toString();
+}
+
+// src/utils/isJsonBody.ts
+function isJsonBody(body) {
+  if (body === null || body === void 0) return false;
+  if (body instanceof FormData) return false;
+  if (body instanceof Blob) return false;
+  if (body instanceof ArrayBuffer) return false;
+  if (body instanceof URLSearchParams) return false;
+  if (body instanceof ReadableStream) return false;
+  if (typeof body === "string") return false;
+  return typeof body === "object";
+}
+
+// src/utils/mergeHeaders.ts
+function mergeHeaders(defaultHeaders, requestHeaders) {
+  if (!defaultHeaders && !requestHeaders) return void 0;
+  if (!defaultHeaders) return requestHeaders;
+  if (!requestHeaders) return defaultHeaders;
+  return {
+    ...Object.fromEntries(new Headers(defaultHeaders)),
+    ...Object.fromEntries(new Headers(requestHeaders))
+  };
+}
+
+// src/core/fetch.ts
+async function executeFetch(baseUrl, path, method, defaultOptions, requestOptions) {
+  const url = buildUrl(baseUrl, path, requestOptions?.query);
+  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
+  const fetchOptions = {
+    ...defaultOptions,
+    method
+  };
+  if (headers) {
+    fetchOptions.headers = headers;
+  }
+  if (requestOptions?.body !== void 0) {
+    if (isJsonBody(requestOptions.body)) {
+      fetchOptions.body = JSON.stringify(requestOptions.body);
+      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
+      if (headers) {
+        fetchOptions.headers = headers;
+      }
+    } else {
+      fetchOptions.body = requestOptions.body;
+    }
+  }
+  const response = await fetch(url, fetchOptions);
+  const contentType = response.headers.get("content-type");
+  const isJson = contentType?.includes("application/json");
+  if (response.ok) {
+    return {
+      ok: true,
+      status: response.status,
+      data: isJson ? await response.json() : response
+    };
+  }
+  return {
+    ok: false,
+    status: response.status,
+    error: isJson ? await response.json() : response
+  };
+}
+
+// src/core/proxy.ts
+var HTTP_METHODS = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  patch: "PATCH",
+  delete: "DELETE"
+};
+function createProxyHandler(baseUrl, defaultOptions, path = [], fetchExecutor = executeFetch) {
+  const handler = {
+    get(_target, prop) {
+      if (typeof prop === "symbol") return void 0;
+      const method = HTTP_METHODS[prop];
+      if (method) {
+        return (options) => fetchExecutor(baseUrl, path, method, defaultOptions, options);
+      }
+      return createProxyHandler(baseUrl, defaultOptions, [...path, prop], fetchExecutor);
+    }
+  };
+  return new Proxy({}, handler);
+}
 
 // src/next/fetch.ts
 function generateTags(path) {
@@ -12,7 +100,7 @@ function generateTags(path) {
 async function executeNextFetch(baseUrl, path, method, defaultOptions, requestOptions) {
   const url = buildUrl(baseUrl, path, requestOptions?.query);
   let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
-  const nextOptions = requestOptions?.next ?? defaultOptions.next;
+  const nextOptions = requestOptions?.next;
   const tags = nextOptions?.tags ?? generateTags(path);
   const fetchOptions = {
     ...defaultOptions,
@@ -44,6 +132,10 @@ async function executeNextFetch(baseUrl, path, method, defaultOptions, requestOp
   const contentType = response.headers.get("content-type");
   const isJson = contentType?.includes("application/json");
   if (response.ok) {
+    const { revalidateTags = [], revalidatePaths = [] } = requestOptions ?? {};
+    if (revalidateTags.length || revalidatePaths.length) {
+      defaultOptions.revalidate?.(revalidateTags, revalidatePaths);
+    }
     return {
       ok: true,
       status: response.status,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enlace",
-  "version": "0.0.0-alpha.2",
+  "version": "0.0.0-alpha.4",
   "files": [
     "dist"
   ],
@@ -21,7 +21,8 @@
     "dev": "tsup --watch",
     "build": "tsup",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint src --max-warnings 0"
+    "lint": "eslint src --max-warnings 0",
+    "prepublishOnly": "npm run build && npm run typecheck && npm run lint"
   },
   "peerDependencies": {
     "react": "^19"
@@ -33,6 +34,7 @@
     "eslint-plugin-react": "^7.37.5",
     "globals": "^16.5.0",
     "jiti": "^2.6.1",
+    "prettier": "^3.7.4",
     "tsup": "^8.5.1",
     "tsx": "^4.21.0",
     "typescript": "5.9.2",

package/dist/chunk-PNORT7RX.mjs

@@ -1,101 +0,0 @@
-// src/utils/buildUrl.ts
-import qs from "query-string";
-function buildUrl(baseUrl, path, query) {
-  const url = new URL(path.join("/"), baseUrl);
-  if (query) {
-    url.search = qs.stringify(query, { skipNull: true, skipEmptyString: true });
-  }
-  return url.toString();
-}
-
-// src/utils/isJsonBody.ts
-function isJsonBody(body) {
-  if (body === null || body === void 0) return false;
-  if (body instanceof FormData) return false;
-  if (body instanceof Blob) return false;
-  if (body instanceof ArrayBuffer) return false;
-  if (body instanceof URLSearchParams) return false;
-  if (body instanceof ReadableStream) return false;
-  if (typeof body === "string") return false;
-  return typeof body === "object";
-}
-
-// src/utils/mergeHeaders.ts
-function mergeHeaders(defaultHeaders, requestHeaders) {
-  if (!defaultHeaders && !requestHeaders) return void 0;
-  if (!defaultHeaders) return requestHeaders;
-  if (!requestHeaders) return defaultHeaders;
-  return {
-    ...Object.fromEntries(new Headers(defaultHeaders)),
-    ...Object.fromEntries(new Headers(requestHeaders))
-  };
-}
-
-// src/core/fetch.ts
-async function executeFetch(baseUrl, path, method, defaultOptions, requestOptions) {
-  const url = buildUrl(baseUrl, path, requestOptions?.query);
-  let headers = mergeHeaders(defaultOptions.headers, requestOptions?.headers);
-  const fetchOptions = {
-    ...defaultOptions,
-    method
-  };
-  if (headers) {
-    fetchOptions.headers = headers;
-  }
-  if (requestOptions?.body !== void 0) {
-    if (isJsonBody(requestOptions.body)) {
-      fetchOptions.body = JSON.stringify(requestOptions.body);
-      headers = mergeHeaders(headers, { "Content-Type": "application/json" });
-      if (headers) {
-        fetchOptions.headers = headers;
-      }
-    } else {
-      fetchOptions.body = requestOptions.body;
-    }
-  }
-  const response = await fetch(url, fetchOptions);
-  const contentType = response.headers.get("content-type");
-  const isJson = contentType?.includes("application/json");
-  if (response.ok) {
-    return {
-      ok: true,
-      status: response.status,
-      data: isJson ? await response.json() : response
-    };
-  }
-  return {
-    ok: false,
-    status: response.status,
-    error: isJson ? await response.json() : response
-  };
-}
-
-// src/core/proxy.ts
-var HTTP_METHODS = {
-  get: "GET",
-  post: "POST",
-  put: "PUT",
-  patch: "PATCH",
-  delete: "DELETE"
-};
-function createProxyHandler(baseUrl, defaultOptions, path = [], fetchExecutor = executeFetch) {
-  const handler = {
-    get(_target, prop) {
-      if (typeof prop === "symbol") return void 0;
-      const method = HTTP_METHODS[prop];
-      if (method) {
-        return (options) => fetchExecutor(baseUrl, path, method, defaultOptions, options);
-      }
-      return createProxyHandler(baseUrl, defaultOptions, [...path, prop], fetchExecutor);
-    }
-  };
-  return new Proxy({}, handler);
-}
-
-export {
-  buildUrl,
-  isJsonBody,
-  mergeHeaders,
-  executeFetch,
-  createProxyHandler
-};

package/dist/types-B-6qIYag.d.mts

@@ -1,104 +0,0 @@
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-type SchemaMethod = '$get' | '$post' | '$put' | '$patch' | '$delete';
-type EnlaceResponse<TData, TError> = {
-    ok: true;
-    status: number;
-    data: TData;
-    error?: never;
-} | {
-    ok: false;
-    status: number;
-    data?: never;
-    error: TError;
-};
-type EnlaceOptions = Omit<RequestInit, 'method' | 'body'>;
-type FetchExecutor<TOptions = EnlaceOptions, TRequestOptions = RequestOptions<unknown>> = <TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: TOptions, requestOptions?: TRequestOptions) => Promise<EnlaceResponse<TData, TError>>;
-type RequestOptions<TBody = never> = {
-    body?: TBody;
-    query?: Record<string, string | number | boolean | undefined>;
-    headers?: HeadersInit;
-};
-type MethodDefinition = {
-    data: unknown;
-    error: unknown;
-    body?: unknown;
-};
-/**
- * Helper to define an endpoint with proper typing.
- * Provides cleaner syntax than writing { data, error, body } manually.
- *
- * @example
- * type MyApi = {
- *   posts: {
- *     $get: Endpoint<Post[], ApiError>;
- *     $post: Endpoint<Post, ApiError, CreatePost>;  // with body
- *     _: {
- *       $get: Endpoint<Post, NotFoundError>;
- *     };
- *   };
- * };
- */
-type Endpoint<TData, TError, TBody = never> = [TBody] extends [never] ? {
-    data: TData;
-    error: TError;
-} : {
-    data: TData;
-    error: TError;
-    body: TBody;
-};
-type ExtractMethodDef<TSchema, TMethod extends SchemaMethod> = TSchema extends {
-    [K in TMethod]: infer M;
-} ? M extends MethodDefinition ? M : never : never;
-type ExtractData<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
-    data: infer D;
-} ? D : never;
-type ExtractError<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
-    error: infer E;
-} ? E : never;
-type ExtractBody<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
-    body: infer B;
-} ? B : never;
-type HasMethod<TSchema, TMethod extends SchemaMethod> = TSchema extends {
-    [K in TMethod]: MethodDefinition;
-} ? true : false;
-type MethodFn<TSchema, TMethod extends SchemaMethod> = HasMethod<TSchema, TMethod> extends true ? ExtractBody<TSchema, TMethod> extends never ? (options?: RequestOptions<never>) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : (options: RequestOptions<ExtractBody<TSchema, TMethod>>) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : never;
-type IsSpecialKey<K> = K extends SchemaMethod | '_' ? true : false;
-type StaticPathKeys<TSchema> = {
-    [K in keyof TSchema as IsSpecialKey<K> extends true ? never : K extends string ? K : never]: TSchema[K];
-};
-type ExtractDynamicSchema<TSchema> = TSchema extends {
-    _: infer D;
-} ? D : never;
-type MethodOrPath<TSchema, TMethodName extends string, TSchemaMethod extends SchemaMethod> = TMethodName extends keyof TSchema ? EnlaceClient<TSchema[TMethodName]> : MethodFn<TSchema, TSchemaMethod>;
-type HttpMethods<TSchema> = {
-    get: MethodOrPath<TSchema, 'get', '$get'>;
-    post: MethodOrPath<TSchema, 'post', '$post'>;
-    put: MethodOrPath<TSchema, 'put', '$put'>;
-    patch: MethodOrPath<TSchema, 'patch', '$patch'>;
-    delete: MethodOrPath<TSchema, 'delete', '$delete'>;
-};
-type DynamicAccess<TSchema> = ExtractDynamicSchema<TSchema> extends never ? object : {
-    [key: string]: EnlaceClient<ExtractDynamicSchema<TSchema>>;
-    [key: number]: EnlaceClient<ExtractDynamicSchema<TSchema>>;
-};
-type MethodNameKeys = 'get' | 'post' | 'put' | 'patch' | 'delete';
-type EnlaceClient<TSchema> = HttpMethods<TSchema> & DynamicAccess<TSchema> & {
-    [K in keyof StaticPathKeys<TSchema> as K extends MethodNameKeys ? never : K]: EnlaceClient<TSchema[K]>;
-};
-type WildcardMethodFn = (options?: RequestOptions<unknown>) => Promise<EnlaceResponse<unknown, unknown>>;
-/**
- * Wildcard client type - allows any path access when no schema is provided.
- * All methods are available at every level and return unknown types.
- */
-type WildcardClient = {
-    get: WildcardMethodFn;
-    post: WildcardMethodFn;
-    put: WildcardMethodFn;
-    patch: WildcardMethodFn;
-    delete: WildcardMethodFn;
-} & {
-    [key: string]: WildcardClient;
-    [key: number]: WildcardClient;
-};
-
-export type { EnlaceOptions as E, FetchExecutor as F, HttpMethod as H, MethodDefinition as M, RequestOptions as R, SchemaMethod as S, WildcardClient as W, EnlaceResponse as a, EnlaceClient as b, Endpoint as c };

package/dist/types-B-6qIYag.d.ts

@@ -1,104 +0,0 @@
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-type SchemaMethod = '$get' | '$post' | '$put' | '$patch' | '$delete';
-type EnlaceResponse<TData, TError> = {
-    ok: true;
-    status: number;
-    data: TData;
-    error?: never;
-} | {
-    ok: false;
-    status: number;
-    data?: never;
-    error: TError;
-};
-type EnlaceOptions = Omit<RequestInit, 'method' | 'body'>;
-type FetchExecutor<TOptions = EnlaceOptions, TRequestOptions = RequestOptions<unknown>> = <TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: TOptions, requestOptions?: TRequestOptions) => Promise<EnlaceResponse<TData, TError>>;
-type RequestOptions<TBody = never> = {
-    body?: TBody;
-    query?: Record<string, string | number | boolean | undefined>;
-    headers?: HeadersInit;
-};
-type MethodDefinition = {
-    data: unknown;
-    error: unknown;
-    body?: unknown;
-};
-/**
- * Helper to define an endpoint with proper typing.
- * Provides cleaner syntax than writing { data, error, body } manually.
- *
- * @example
- * type MyApi = {
- *   posts: {
- *     $get: Endpoint<Post[], ApiError>;
- *     $post: Endpoint<Post, ApiError, CreatePost>;  // with body
- *     _: {
- *       $get: Endpoint<Post, NotFoundError>;
- *     };
- *   };
- * };
- */
-type Endpoint<TData, TError, TBody = never> = [TBody] extends [never] ? {
-    data: TData;
-    error: TError;
-} : {
-    data: TData;
-    error: TError;
-    body: TBody;
-};
-type ExtractMethodDef<TSchema, TMethod extends SchemaMethod> = TSchema extends {
-    [K in TMethod]: infer M;
-} ? M extends MethodDefinition ? M : never : never;
-type ExtractData<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
-    data: infer D;
-} ? D : never;
-type ExtractError<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
-    error: infer E;
-} ? E : never;
-type ExtractBody<TSchema, TMethod extends SchemaMethod> = ExtractMethodDef<TSchema, TMethod> extends {
-    body: infer B;
-} ? B : never;
-type HasMethod<TSchema, TMethod extends SchemaMethod> = TSchema extends {
-    [K in TMethod]: MethodDefinition;
-} ? true : false;
-type MethodFn<TSchema, TMethod extends SchemaMethod> = HasMethod<TSchema, TMethod> extends true ? ExtractBody<TSchema, TMethod> extends never ? (options?: RequestOptions<never>) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : (options: RequestOptions<ExtractBody<TSchema, TMethod>>) => Promise<EnlaceResponse<ExtractData<TSchema, TMethod>, ExtractError<TSchema, TMethod>>> : never;
-type IsSpecialKey<K> = K extends SchemaMethod | '_' ? true : false;
-type StaticPathKeys<TSchema> = {
-    [K in keyof TSchema as IsSpecialKey<K> extends true ? never : K extends string ? K : never]: TSchema[K];
-};
-type ExtractDynamicSchema<TSchema> = TSchema extends {
-    _: infer D;
-} ? D : never;
-type MethodOrPath<TSchema, TMethodName extends string, TSchemaMethod extends SchemaMethod> = TMethodName extends keyof TSchema ? EnlaceClient<TSchema[TMethodName]> : MethodFn<TSchema, TSchemaMethod>;
-type HttpMethods<TSchema> = {
-    get: MethodOrPath<TSchema, 'get', '$get'>;
-    post: MethodOrPath<TSchema, 'post', '$post'>;
-    put: MethodOrPath<TSchema, 'put', '$put'>;
-    patch: MethodOrPath<TSchema, 'patch', '$patch'>;
-    delete: MethodOrPath<TSchema, 'delete', '$delete'>;
-};
-type DynamicAccess<TSchema> = ExtractDynamicSchema<TSchema> extends never ? object : {
-    [key: string]: EnlaceClient<ExtractDynamicSchema<TSchema>>;
-    [key: number]: EnlaceClient<ExtractDynamicSchema<TSchema>>;
-};
-type MethodNameKeys = 'get' | 'post' | 'put' | 'patch' | 'delete';
-type EnlaceClient<TSchema> = HttpMethods<TSchema> & DynamicAccess<TSchema> & {
-    [K in keyof StaticPathKeys<TSchema> as K extends MethodNameKeys ? never : K]: EnlaceClient<TSchema[K]>;
-};
-type WildcardMethodFn = (options?: RequestOptions<unknown>) => Promise<EnlaceResponse<unknown, unknown>>;
-/**
- * Wildcard client type - allows any path access when no schema is provided.
- * All methods are available at every level and return unknown types.
- */
-type WildcardClient = {
-    get: WildcardMethodFn;
-    post: WildcardMethodFn;
-    put: WildcardMethodFn;
-    patch: WildcardMethodFn;
-    delete: WildcardMethodFn;
-} & {
-    [key: string]: WildcardClient;
-    [key: number]: WildcardClient;
-};
-
-export type { EnlaceOptions as E, FetchExecutor as F, HttpMethod as H, MethodDefinition as M, RequestOptions as R, SchemaMethod as S, WildcardClient as W, EnlaceResponse as a, EnlaceClient as b, Endpoint as c };