@spoosh/core 0.5.0 → 0.7.0

package/dist/index.d.mts

@@ -1,5 +1,4 @@
 type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-type SchemaMethod = "$get" | "$post" | "$put" | "$patch" | "$delete";
 
 type MiddlewarePhase = "before" | "after";
 type MiddlewareContext<TData = unknown, TError = unknown> = {
@@ -71,41 +70,27 @@ type HeadersInitOrGetter = HeadersInit | (() => HeadersInit | Promise<HeadersIni
 type SpooshOptions = Omit<RequestInit, "method" | "body" | "headers"> & {
     headers?: HeadersInitOrGetter;
 };
-type BaseRequestOptions = {
+type BaseRequestOptions$1 = {
     headers?: HeadersInitOrGetter;
     cache?: RequestCache;
     signal?: AbortSignal;
 };
-type BodyOption<TBody> = [TBody] extends [never] ? object : undefined extends TBody ? {
+type BodyOption$1<TBody> = [TBody] extends [never] ? object : undefined extends TBody ? {
     body?: Exclude<TBody, undefined>;
 } : {
     body: TBody;
 };
-type QueryOption<TQuery> = [TQuery] extends [never] ? object : undefined extends TQuery ? {
+type QueryOption$1<TQuery> = [TQuery] extends [never] ? object : undefined extends TQuery ? {
     query?: Exclude<TQuery, undefined>;
 } : {
     query: TQuery;
 };
-type FormDataOption<TFormData> = [TFormData] extends [never] ? object : undefined extends TFormData ? {
-    formData?: Exclude<TFormData, undefined>;
-} : {
-    formData: TFormData;
-};
-type UrlEncodedOption<TUrlEncoded> = [TUrlEncoded] extends [never] ? object : undefined extends TUrlEncoded ? {
-    urlEncoded?: Exclude<TUrlEncoded, undefined>;
-} : {
-    urlEncoded: TUrlEncoded;
-};
-type RequestOptions<TBody = never, TQuery = never, TFormData = never, TUrlEncoded = never> = BaseRequestOptions & BodyOption<TBody> & QueryOption<TQuery> & FormDataOption<TFormData> & UrlEncodedOption<TUrlEncoded>;
-type AnyRequestOptions = BaseRequestOptions & {
+type RequestOptions$1<TBody = never, TQuery = never> = BaseRequestOptions$1 & BodyOption$1<TBody> & QueryOption$1<TQuery>;
+type AnyRequestOptions = BaseRequestOptions$1 & {
     body?: unknown;
     query?: Record<string, string | number | boolean | undefined>;
-    formData?: Record<string, unknown>;
-    urlEncoded?: Record<string, unknown>;
     params?: Record<string, string | number>;
     signal?: AbortSignal;
-    /** @internal Path transformer function. Set by plugins like path-case. */
-    _pathTransformer?: (path: string[]) => string[];
 } & Partial<RetryConfig>;
 type DynamicParamsOption = {
     params?: Record<string, string | number>;
@@ -114,13 +99,13 @@ type CoreRequestOptionsBase = {
     __hasDynamicParams?: DynamicParamsOption;
 };
 type MethodOptionsMap<TQueryOptions = object, TMutationOptions = object> = {
-    $get: TQueryOptions;
-    $post: TMutationOptions;
-    $put: TMutationOptions;
-    $patch: TMutationOptions;
-    $delete: TMutationOptions;
+    GET: TQueryOptions;
+    POST: TMutationOptions;
+    PUT: TMutationOptions;
+    PATCH: TMutationOptions;
+    DELETE: TMutationOptions;
 };
-type ExtractMethodOptions<TOptionsMap, TMethod extends SchemaMethod> = TOptionsMap extends MethodOptionsMap<infer TQuery, infer TMutation> ? TMethod extends "$get" ? TQuery : TMutation : TOptionsMap;
+type ExtractMethodOptions<TOptionsMap, TMethod extends HttpMethod> = TOptionsMap extends MethodOptionsMap<infer TQuery, infer TMutation> ? TMethod extends "GET" ? TQuery : TMutation : TOptionsMap;
 type FetchExecutor<TOptions = SpooshOptions, TRequestOptions = AnyRequestOptions> = <TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: TOptions, requestOptions?: TRequestOptions, nextTags?: boolean) => Promise<SpooshResponse<TData, TError>>;
 type TypedParamsOption<TParamNames extends string> = [TParamNames] extends [
     never
@@ -448,7 +433,7 @@ type DataAwareTransform<TData = unknown, TError = unknown> = (data: TData | unde
  * Context object containing all type information available for resolution.
  * 3rd party plugins can access any combination of these types.
  */
-type ResolverContext<TSchema = unknown, TData = unknown, TError = unknown, TQuery = unknown, TBody = unknown, TParams = unknown, TFormData = unknown, TUrlEncoded = unknown> = {
+type ResolverContext<TSchema = unknown, TData = unknown, TError = unknown, TQuery = unknown, TBody = unknown, TParams = unknown> = {
     schema: TSchema;
     data: TData;
     error: TError;
@@ -456,8 +441,6 @@ type ResolverContext<TSchema = unknown, TData = unknown, TError = unknown, TQuer
         query: TQuery;
         body: TBody;
         params: TParams;
-        formData: TFormData;
-        urlEncoded: TUrlEncoded;
     };
 };
 /**
@@ -704,175 +687,166 @@ type PluginRegistry<TPlugins extends SpooshPlugin<PluginTypeConfig>[]> = {
 };
 declare function createPluginRegistry<TPlugins extends SpooshPlugin<PluginTypeConfig>[]>(plugins: [...TPlugins]): PluginRegistry<TPlugins>;
 
-declare const EndpointBrand: unique symbol;
 /**
- * Define an API endpoint with its data, request options, and error types.
+ * An API schema where routes are defined as string keys with path patterns.
+ * Define data, body, query, and error directly on each method.
  *
  * @example
- * ```typescript
- * // Simple GET endpoint
- * $get: Endpoint<{ data: User[] }>
- *
- * // GET with query parameters
- * $get: Endpoint<{ data: User[]; query: { page: number; limit: number } }>
- *
- * // POST with JSON body
- * $post: Endpoint<{ data: User; body: CreateUserBody }>
- *
- * // POST with form data (file upload)
- * $post: Endpoint<{ data: UploadResult; formData: { file: File; name: string } }>
- *
- * // POST with URL-encoded body (Stripe-style)
- * $post: Endpoint<{ data: Payment; urlEncoded: { amount: number; currency: string } }>
- *
- * // With error type
- * $get: Endpoint<{ data: User; error: ApiError }>
- *
- * // Complex: query + body + error
- * $post: Endpoint<{ data: User; body: CreateUserBody; query: { notify?: boolean }; error: ApiError }>
+ * ```ts
+ * type ApiSchema = {
+ *   "posts": {
+ *     GET: { data: Post[] };
+ *     POST: { data: Post; body: CreatePostBody };
+ *   };
+ *   "posts/:id": {
+ *     GET: { data: Post };
+ *     PUT: { data: Post; body: UpdatePostBody };
+ *     DELETE: { data: void };
+ *   };
+ *   "posts/:id/comments": {
+ *     GET: { data: Comment[]; query: { page?: number } };
+ *   };
+ * };
  * ```
  */
-type Endpoint<T extends {
-    data: unknown;
-    body?: unknown;
-    query?: unknown;
-    formData?: unknown;
-    urlEncoded?: unknown;
-    error?: unknown;
-}> = {
-    [EndpointBrand]: true;
-} & T;
-type ExtractProperty<T, K extends string, TDefault = never> = K extends keyof T ? T[K] : TDefault;
-type NormalizeEndpoint<T, TDefaultError> = T extends {
-    [EndpointBrand]: true;
-} ? {
-    data: ExtractProperty<T, "data">;
-    error: ExtractProperty<T, "error", TDefaultError>;
-    body: ExtractProperty<T, "body">;
-    query: ExtractProperty<T, "query">;
-    formData: ExtractProperty<T, "formData">;
-    urlEncoded: ExtractProperty<T, "urlEncoded">;
-} : {
-    data: T;
-    error: TDefaultError;
-    body: never;
-    query: never;
-    formData: never;
-    urlEncoded: never;
+type ApiSchema = {
+    [path: string]: {
+        [method in HttpMethod]?: {
+            data: unknown;
+            body?: unknown;
+            query?: unknown;
+            error?: unknown;
+        };
+    };
 };
-type ExtractMethodDef<TSchema, TMethod extends SchemaMethod, TDefaultError = unknown> = TSchema extends {
-    [K in TMethod]: infer M;
-} ? NormalizeEndpoint<M, TDefaultError> : never;
-type ExtractData<TSchema, TMethod extends SchemaMethod, TDefaultError = unknown> = ExtractMethodDef<TSchema, TMethod, TDefaultError> extends {
+/**
+ * Extract data type from an endpoint.
+ */
+type ExtractData<T> = T extends {
     data: infer D;
 } ? D : never;
-type ExtractError<TSchema, TMethod extends SchemaMethod, TDefaultError = unknown> = ExtractMethodDef<TSchema, TMethod, TDefaultError> extends {
-    error: infer E;
-} ? E : TDefaultError;
-type ExtractBody<TSchema, TMethod extends SchemaMethod, TDefaultError = unknown> = ExtractMethodDef<TSchema, TMethod, TDefaultError> extends {
+/**
+ * Extract body type from an endpoint.
+ */
+type ExtractBody$1<T> = T extends {
     body: infer B;
 } ? B : never;
-type ExtractQuery<TSchema, TMethod extends SchemaMethod, TDefaultError = unknown> = ExtractMethodDef<TSchema, TMethod, TDefaultError> extends {
+/**
+ * Extract query type from an endpoint.
+ */
+type ExtractQuery$1<T> = T extends {
     query: infer Q;
 } ? Q : never;
-type ExtractFormData<TSchema, TMethod extends SchemaMethod, TDefaultError = unknown> = ExtractMethodDef<TSchema, TMethod, TDefaultError> extends {
-    formData: infer F;
-} ? F : never;
-type ExtractUrlEncoded<TSchema, TMethod extends SchemaMethod, TDefaultError = unknown> = ExtractMethodDef<TSchema, TMethod, TDefaultError> extends {
-    urlEncoded: infer U;
-} ? U : never;
-type HasMethod<TSchema, TMethod extends SchemaMethod> = TSchema extends {
-    [K in TMethod]: unknown;
-} ? true : false;
-type HasRequiredOptions<TSchema, TMethod extends SchemaMethod, TDefaultError = unknown> = [ExtractBody<TSchema, TMethod, TDefaultError>] extends [never] ? [ExtractFormData<TSchema, TMethod, TDefaultError>] extends [never] ? [ExtractUrlEncoded<TSchema, TMethod, TDefaultError>] extends [never] ? false : true : true : true;
-
-type ExtractParamName$1<S> = S extends `:${infer P}` ? P : never;
-type MethodRequestOptions<TSchema, TMethod extends SchemaMethod, TDefaultError, TOptionsMap, TParamNames extends string, TRequired extends boolean> = TRequired extends true ? RequestOptions<ExtractBody<TSchema, TMethod, TDefaultError>, ExtractQuery<TSchema, TMethod, TDefaultError>, ExtractFormData<TSchema, TMethod, TDefaultError>, ExtractUrlEncoded<TSchema, TMethod, TDefaultError>> & ComputeRequestOptions<ExtractMethodOptions<TOptionsMap, TMethod>, TParamNames> : RequestOptions<never, ExtractQuery<TSchema, TMethod, TDefaultError>, never, never> & ComputeRequestOptions<ExtractMethodOptions<TOptionsMap, TMethod>, TParamNames>;
-type MethodFn<TSchema, TMethod extends SchemaMethod, TDefaultError = unknown, TOptionsMap = object, TParamNames extends string = never> = HasMethod<TSchema, TMethod> extends true ? HasRequiredOptions<TSchema, TMethod, TDefaultError> extends true ? (options: MethodRequestOptions<TSchema, TMethod, TDefaultError, TOptionsMap, TParamNames, true>) => Promise<SpooshResponse<ExtractData<TSchema, TMethod, TDefaultError>, ExtractError<TSchema, TMethod, TDefaultError>, MethodRequestOptions<TSchema, TMethod, TDefaultError, TOptionsMap, TParamNames, true>, ExtractQuery<TSchema, TMethod, TDefaultError>, ExtractBody<TSchema, TMethod, TDefaultError>, ExtractFormData<TSchema, TMethod, TDefaultError>, ExtractUrlEncoded<TSchema, TMethod, TDefaultError>, TParamNames>> : (options?: MethodRequestOptions<TSchema, TMethod, TDefaultError, TOptionsMap, TParamNames, false>) => Promise<SpooshResponse<ExtractData<TSchema, TMethod, TDefaultError>, ExtractError<TSchema, TMethod, TDefaultError>, MethodRequestOptions<TSchema, TMethod, TDefaultError, TOptionsMap, TParamNames, false>, ExtractQuery<TSchema, TMethod, TDefaultError>, ExtractBody<TSchema, TMethod, TDefaultError>, ExtractFormData<TSchema, TMethod, TDefaultError>, ExtractUrlEncoded<TSchema, TMethod, TDefaultError>, TParamNames>> : 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 HttpMethods<TSchema, TDefaultError = unknown, TOptionsMap = object, TParamNames extends string = never> = {
-    [K in SchemaMethod as K extends keyof TSchema ? K : never]: MethodFn<TSchema, K, TDefaultError, TOptionsMap, TParamNames>;
-};
-type DynamicAccess<TSchema, TDefaultError = unknown, TOptionsMap = object, TParamNames extends string = never, TRootSchema = TSchema> = ExtractDynamicSchema<TSchema> extends never ? object : {
-    /**
-     * Dynamic path segment with typed param name.
-     * Use `:paramName` format to get typed params in the response.
-     *
-     * @example
-     * ```ts
-     * // With number
-     * await api.users(123).$get()
-     *
-     * // With typed params
-     * const { data, params } = await api.users(':userId').$get({ params: { userId: 123 } })
-     * ```
-     */
-    <TKey extends string | number>(key: TKey): SpooshClient<ExtractDynamicSchema<TSchema>, TDefaultError, TOptionsMap, TParamNames | ExtractParamName$1<TKey>, TRootSchema>;
-};
-type SpooshClient<TSchema, TDefaultError = unknown, TOptionsMap = object, TParamNames extends string = never, TRootSchema = TSchema> = HttpMethods<TSchema, TDefaultError, TOptionsMap, TParamNames> & DynamicAccess<TSchema, TDefaultError, TOptionsMap, TParamNames, TRootSchema> & {
-    [K in keyof StaticPathKeys<TSchema> as K extends SchemaMethod ? never : K]: SpooshClient<TSchema[K], TDefaultError, TOptionsMap, TParamNames, TRootSchema>;
-};
-
-type QueryMethod = "$get";
-type MutationMethod = "$post" | "$put" | "$patch" | "$delete";
-type HasQueryMethods<TSchema> = TSchema extends object ? "$get" extends keyof TSchema ? true : TSchema extends {
-    _: infer D;
-} ? HasQueryMethods<D> : {
-    [K in keyof TSchema]: K extends SchemaMethod | "_" ? never : HasQueryMethods<TSchema[K]>;
-}[keyof TSchema] extends never ? false : true extends {
-    [K in keyof TSchema]: K extends SchemaMethod | "_" ? never : HasQueryMethods<TSchema[K]>;
-}[keyof TSchema] ? true : false : false;
-type HasMutationMethods<TSchema> = TSchema extends object ? MutationMethod extends never ? false : Extract<keyof TSchema, MutationMethod> extends never ? TSchema extends {
-    _: infer D;
-} ? HasMutationMethods<D> : {
-    [K in keyof TSchema]: K extends SchemaMethod | "_" ? never : HasMutationMethods<TSchema[K]>;
-}[keyof TSchema] extends never ? false : true extends {
-    [K in keyof TSchema]: K extends SchemaMethod | "_" ? never : HasMutationMethods<TSchema[K]>;
-}[keyof TSchema] ? true : false : true : false;
-type QueryHttpMethods<TSchema, TDefaultError = unknown, TOptionsMap = object, TParamNames extends string = never> = {
-    [K in QueryMethod as K extends keyof TSchema ? K : never]: MethodFn<TSchema, K, TDefaultError, TOptionsMap, TParamNames>;
-};
-type ExtractParamName<S> = S extends `:${infer P}` ? P : never;
-type QueryDynamicAccess<TSchema, TDefaultError = unknown, TOptionsMap = object, TParamNames extends string = never, TRootSchema = TSchema> = TSchema extends {
-    _: infer D;
-} ? HasQueryMethods<D> extends true ? {
-    <TKey extends string | number>(key: TKey): QueryOnlyClient<D, TDefaultError, TOptionsMap, TParamNames | ExtractParamName<TKey>, TRootSchema>;
-} : object : object;
-type QueryOnlyClient<TSchema, TDefaultError = unknown, TOptionsMap = object, TParamNames extends string = never, TRootSchema = TSchema> = QueryHttpMethods<TSchema, TDefaultError, TOptionsMap, TParamNames> & QueryDynamicAccess<TSchema, TDefaultError, TOptionsMap, TParamNames, TRootSchema> & {
-    [K in keyof StaticPathKeys<TSchema> as K extends SchemaMethod ? never : HasQueryMethods<TSchema[K]> extends true ? K : never]: QueryOnlyClient<TSchema[K], TDefaultError, TOptionsMap, TParamNames, TRootSchema>;
-};
-type MutationHttpMethods<TSchema, TDefaultError = unknown, TOptionsMap = object, TParamNames extends string = never> = {
-    [K in MutationMethod as K extends keyof TSchema ? K : never]: MethodFn<TSchema, K, TDefaultError, TOptionsMap, TParamNames>;
-};
-type MutationDynamicAccess<TSchema, TDefaultError = unknown, TOptionsMap = object, TParamNames extends string = never> = TSchema extends {
-    _: infer D;
-} ? HasMutationMethods<D> extends true ? {
-    <TKey extends string | number>(key: TKey): MutationOnlyClient<D, TDefaultError, TOptionsMap, TParamNames | ExtractParamName<TKey>>;
-} : object : object;
-type MutationOnlyClient<TSchema, TDefaultError = unknown, TOptionsMap = object, TParamNames extends string = never> = MutationHttpMethods<TSchema, TDefaultError, TOptionsMap, TParamNames> & MutationDynamicAccess<TSchema, TDefaultError, TOptionsMap, TParamNames> & {
-    [K in keyof StaticPathKeys<TSchema> as K extends SchemaMethod ? never : HasMutationMethods<TSchema[K]> extends true ? K : never]: MutationOnlyClient<TSchema[K], TDefaultError, TOptionsMap, TParamNames>;
-};
+/**
+ * Extract error type from an endpoint.
+ */
+type ExtractError<T, TDefault = unknown> = T extends {
+    error: infer E;
+} ? E : TDefault;
+/**
+ * Helper type to define a type-safe API schema.
+ * Use this to get type checking on your schema definition.
+ *
+ * @example
+ * ```ts
+ * type ApiSchema = SpooshSchema<{
+ *   "posts": {
+ *     GET: { data: Post[] };
+ *     POST: { data: Post; body: CreatePostBody };
+ *   };
+ *   "posts/:id": {
+ *     GET: { data: Post };
+ *     PUT: { data: Post; body: UpdatePostBody };
+ *     DELETE: { data: void };
+ *   };
+ * }>;
+ *
+ * const api = createClient<ApiSchema>({ baseUrl: "/api" });
+ * ```
+ */
+type SpooshSchema<T extends {
+    [path: string]: {
+        [M in HttpMethod]?: {
+            data: unknown;
+            body?: unknown;
+            query?: unknown;
+            error?: unknown;
+        };
+    };
+}> = T;
+/**
+ * Convert a route pattern like "posts/:id" to a path matcher pattern like `posts/${string}`.
+ * This enables TypeScript to match actual paths like "posts/123" to their schema definitions.
+ *
+ * @example
+ * ```ts
+ * type A = RouteToPath<"posts/:id">; // "posts/${string}"
+ * type B = RouteToPath<"posts/:id/comments/:cid">; // "posts/${string}/comments/${string}"
+ * type C = RouteToPath<"posts">; // "posts"
+ * ```
+ */
+type RouteToPath<T extends string> = T extends `${infer Start}/:${string}/${infer Rest}` ? `${Start}/${string}/${RouteToPath<Rest>}` : T extends `${infer Start}/:${string}` ? `${Start}/${string}` : T;
+/**
+ * Find which schema key matches a given path.
+ * First checks for exact match, then checks pattern matches.
+ *
+ * @example
+ * ```ts
+ * type Schema = { "posts": {...}; "posts/:id": {...} };
+ * type A = FindMatchingKey<Schema, "posts">; // "posts" (exact match)
+ * type B = FindMatchingKey<Schema, "posts/123">; // "posts/:id" (pattern match)
+ * ```
+ */
+type FindMatchingKey<TSchema, TPath extends string> = TPath extends keyof TSchema ? TPath : {
+    [K in keyof TSchema]: TPath extends RouteToPath<K & string> ? K : never;
+}[keyof TSchema];
+/**
+ * Extract parameter names from a route pattern.
+ *
+ * @example
+ * ```ts
+ * type A = ExtractParamNames<"posts/:id">; // "id"
+ * type B = ExtractParamNames<"posts/:id/comments/:cid">; // "id" | "cid"
+ * type C = ExtractParamNames<"posts">; // never
+ * ```
+ */
+type ExtractParamNames<T extends string> = T extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractParamNames<Rest> : T extends `${string}:${infer Param}` ? Param : never;
+/**
+ * Check if a route pattern has any parameters.
+ *
+ * @example
+ * ```ts
+ * type A = HasParams<"posts/:id">; // true
+ * type B = HasParams<"posts">; // false
+ * ```
+ */
+type HasParams<T extends string> = T extends `${string}:${string}` ? true : false;
 
-type ExtractEndpointData<T> = T extends {
-    data: infer D;
-} ? D : T extends void ? void : T;
-type ExtractEndpointRequestOptions<T> = {
-    [K in Extract<keyof T, "query" | "body" | "params">]?: T[K];
-};
-type EndpointToMethod<T> = (options?: ExtractEndpointRequestOptions<T>) => Promise<SpooshResponse<ExtractEndpointData<T>, unknown, ExtractEndpointRequestOptions<T>>>;
+type Simplify$1<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type IsNever<T> = [T] extends [never] ? true : false;
+type EndpointRequestOptions<TEndpoint, TPath extends string> = (IsNever<ExtractBody$1<TEndpoint>> extends true ? object : {
+    body: ExtractBody$1<TEndpoint>;
+}) & (IsNever<ExtractQuery$1<TEndpoint>> extends true ? object : {
+    query: ExtractQuery$1<TEndpoint>;
+}) & (HasParams<TPath> extends true ? {
+    params: Record<ExtractParamNames<TPath>, string | number>;
+} : object);
+type EndpointMethodFn<TEndpoint, TPath extends string> = (options?: Simplify$1<EndpointRequestOptions<TEndpoint, TPath>>) => Promise<SpooshResponse<ExtractData<TEndpoint>, unknown, EndpointRequestOptions<TEndpoint, TPath>>>;
+type QueryPathMethods<TSchema, TPath extends string> = FindMatchingKey<TSchema, TPath> extends infer TKey ? TKey extends keyof TSchema ? "GET" extends keyof TSchema[TKey] ? Simplify$1<{
+    GET: EndpointMethodFn<TSchema[TKey]["GET"], TPath>;
+}> : never : never : never;
+type ReadPaths$1<TSchema> = {
+    [K in keyof TSchema & string]: "GET" extends keyof TSchema[K] ? K : never;
+}[keyof TSchema & string];
+type HasGetMethod$1<TSchema, TPath extends string> = FindMatchingKey<TSchema, TPath> extends infer TKey ? TKey extends keyof TSchema ? "GET" extends keyof TSchema[TKey] ? true : false : false : false;
 /**
  * Schema navigation helper for plugins that need type-safe API schema access.
  *
- * This type transforms the API schema into a navigable structure where:
- * - Static path segments become nested properties
- * - Dynamic segments (`_`) become index signatures
- * - `$get` endpoints become callable method types
+ * This type transforms the API schema into a callable function where:
+ * - Path strings are used to select endpoints
+ * - Only GET methods are exposed (for query operations)
  *
  * Use this in plugin option types that need to reference API endpoints:
  *
@@ -901,22 +875,182 @@ type EndpointToMethod<T> = (options?: ExtractEndpointRequestOptions<T>) => Promi
  * // User's code - paths are type-checked!
  * trigger({
  *   myCallback: (api) => [
- *     api.posts.$get,           // ✓ Valid
- *     api.users(1).$get,        // ✓ Dynamic segment
- *     api.nonexistent.$get,     // ✗ Type error
+ *     api("posts").GET,           // ✓ Valid
+ *     api("posts/:id").GET,       // ✓ Dynamic segment
+ *     api("nonexistent").GET,     // ✗ Type error
  *   ],
  * });
  * ```
  */
-type QuerySchemaHelper<TSchema> = {
-    [K in keyof TSchema as K extends SchemaMethod | "_" ? never : HasQueryMethods<TSchema[K]> extends true ? K : never]: K extends keyof TSchema ? QuerySchemaHelper<TSchema[K]> : never;
-} & {
-    [K in "$get" as K extends keyof TSchema ? K : never]: K extends keyof TSchema ? EndpointToMethod<TSchema[K]> : never;
-} & (TSchema extends {
-    _: infer D;
-} ? HasQueryMethods<D> extends true ? {
-    <TKey extends string | number>(key: TKey): QuerySchemaHelper<D>;
-} : object : object);
+type QuerySchemaHelper<TSchema> = <TPath extends ReadPaths$1<TSchema> | (string & {})>(path: TPath) => HasGetMethod$1<TSchema, TPath> extends true ? QueryPathMethods<TSchema, TPath> : never;
+type MutationMethod$1 = "POST" | "PUT" | "PATCH" | "DELETE";
+type MutationPathMethods<TSchema, TPath extends string> = FindMatchingKey<TSchema, TPath> extends infer TKey ? TKey extends keyof TSchema ? Simplify$1<{
+    [M in MutationMethod$1 as M extends keyof TSchema[TKey] ? M : never]: M extends keyof TSchema[TKey] ? EndpointMethodFn<TSchema[TKey][M], TPath> : never;
+}> : never : never;
+type WritePaths$1<TSchema> = {
+    [K in keyof TSchema & string]: Extract<keyof TSchema[K], MutationMethod$1> extends never ? never : K;
+}[keyof TSchema & string];
+type HasMutationMethod$1<TSchema, TPath extends string> = FindMatchingKey<TSchema, TPath> extends infer TKey ? TKey extends keyof TSchema ? MutationMethod$1 extends never ? false : Extract<keyof TSchema[TKey], MutationMethod$1> extends never ? false : true : false : false;
+/**
+ * Schema navigation helper for plugins that need type-safe API schema access for mutations.
+ *
+ * Similar to QuerySchemaHelper but exposes mutation methods (POST, PUT, PATCH, DELETE).
+ */
+type MutationSchemaHelper<TSchema> = <TPath extends WritePaths$1<TSchema> | (string & {})>(path: TPath) => HasMutationMethod$1<TSchema, TPath> extends true ? MutationPathMethods<TSchema, TPath> : never;
+
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Base request options available on all methods.
+ */
+type BaseRequestOptions = {
+    headers?: HeadersInitOrGetter;
+    cache?: RequestCache;
+    signal?: AbortSignal;
+};
+/**
+ * Extract body type from method config.
+ */
+type ExtractBody<T> = T extends {
+    body?: infer B;
+} ? B : never;
+/**
+ * Extract query type from method config.
+ */
+type ExtractQuery<T> = T extends {
+    query?: infer Q;
+} ? Q : never;
+/**
+ * Check if body is required (not optional).
+ */
+type IsBodyRequired<T> = T extends {
+    body: infer B;
+} ? undefined extends B ? false : true : false;
+/**
+ * Check if query is required (not optional).
+ */
+type IsQueryRequired<T> = T extends {
+    query: infer Q;
+} ? undefined extends Q ? false : true : false;
+/**
+ * Build the options type for a method.
+ */
+type BodyOption<T> = [ExtractBody<T>] extends [never] ? {} : IsBodyRequired<T> extends true ? {
+    body: ExtractBody<T>;
+} : {
+    body?: ExtractBody<T>;
+};
+type QueryOption<T> = [ExtractQuery<T>] extends [never] ? {} : IsQueryRequired<T> extends true ? {
+    query: ExtractQuery<T>;
+} : {
+    query?: ExtractQuery<T>;
+};
+type ParamsOption<TUserPath extends string> = HasParams<TUserPath> extends true ? {
+    params: Record<ExtractParamNames<TUserPath>, string | number>;
+} : {};
+type RequestOptions<TMethodConfig, TUserPath extends string> = Simplify<BaseRequestOptions & BodyOption<TMethodConfig> & QueryOption<TMethodConfig> & ParamsOption<TUserPath>>;
+/**
+ * Check if options argument is required.
+ */
+type IsOptionsRequired<TMethodConfig, TUserPath extends string> = IsBodyRequired<TMethodConfig> extends true ? true : IsQueryRequired<TMethodConfig> extends true ? true : HasParams<TUserPath> extends true ? true : false;
+/**
+ * Build response type for a method call.
+ */
+type MethodResponse<TMethodConfig, TDefaultError, TUserPath extends string> = SpooshResponse<ExtractData<TMethodConfig>, ExtractError<TMethodConfig, TDefaultError>, RequestOptions<TMethodConfig, TUserPath>, ExtractQuery<TMethodConfig>, ExtractBody<TMethodConfig>, never, never, ExtractParamNames<TUserPath>>;
+/**
+ * Create a method function type.
+ * Direct lookup: Schema[Path][Method] → method config → build function type
+ */
+type MethodFn<TMethodConfig, TDefaultError, TUserPath extends string> = IsOptionsRequired<TMethodConfig, TUserPath> extends true ? (options: RequestOptions<TMethodConfig, TUserPath>) => Promise<MethodResponse<TMethodConfig, TDefaultError, TUserPath>> : (options?: RequestOptions<TMethodConfig, TUserPath>) => Promise<MethodResponse<TMethodConfig, TDefaultError, TUserPath>>;
+/**
+ * HTTP methods available on a path.
+ * Direct lookup: Schema[Path] → route config → map methods
+ */
+type HttpMethods<TRoute, TDefaultError, TUserPath extends string> = {
+    [M in HttpMethod as M extends keyof TRoute ? M : never]: M extends keyof TRoute ? MethodFn<TRoute[M], TDefaultError, TUserPath> : never;
+};
+/**
+ * Build the return type when calling a client with a path.
+ * Uses FindMatchingKey for pattern matching (e.g., "posts/123" → "posts/:id")
+ */
+type PathMethods<TSchema, TPath extends string, TDefaultError> = FindMatchingKey<TSchema, TPath> extends infer TKey ? TKey extends keyof TSchema ? Simplify<HttpMethods<TSchema[TKey], TDefaultError, TPath>> : never : never;
+/**
+ * Extract all valid paths from a schema (for autocomplete).
+ */
+type SchemaPaths<TSchema> = keyof TSchema & string;
+/**
+ * An API client that uses path strings instead of chained property access.
+ * Methods use HTTP names directly: GET, POST, PUT, PATCH, DELETE.
+ *
+ * @example
+ * ```ts
+ * type ApiSchema = {
+ *   "posts": { GET: { data: Post[] } };
+ *   "posts/:id": { GET: { data: Post } };
+ * };
+ *
+ * const api = createClient<ApiSchema>({ baseUrl: "/api" });
+ *
+ * // Call with exact path (autocomplete available)
+ * await api("posts").GET();
+ *
+ * // Call with embedded params (matches "posts/:id")
+ * await api("posts/123").GET();
+ *
+ * // Call with explicit params
+ * await api("posts/:id").GET({ params: { id: 123 } });
+ * ```
+ */
+type SpooshClient<TSchema, TDefaultError = unknown> = <TPath extends SchemaPaths<TSchema> | (string & {})>(path: TPath) => PathMethods<TSchema, TPath, TDefaultError>;
+/**
+ * Read-only client type that only exposes GET methods.
+ * Used by useRead/injectRead hooks to ensure only query operations are selected.
+ */
+type ReadPathMethods<TSchema, TPath extends string, TDefaultError> = FindMatchingKey<TSchema, TPath> extends infer TKey ? TKey extends keyof TSchema ? "GET" extends keyof TSchema[TKey] ? Simplify<{
+    GET: MethodFn<TSchema[TKey]["GET"], TDefaultError, TPath>;
+}> : never : never : never;
+/**
+ * Check if a schema path has a GET method.
+ */
+type HasGetMethod<TSchema, TPath extends string> = FindMatchingKey<TSchema, TPath> extends infer TKey ? TKey extends keyof TSchema ? "GET" extends keyof TSchema[TKey] ? true : false : false : false;
+/**
+ * Extract paths that have GET methods.
+ */
+type ReadPaths<TSchema> = {
+    [K in keyof TSchema & string]: "GET" extends keyof TSchema[K] ? K : never;
+}[keyof TSchema & string];
+/**
+ * A read-only API client that only exposes GET methods.
+ * Used by useRead and injectRead hooks.
+ */
+type ReadClient<TSchema, TDefaultError = unknown> = <TPath extends ReadPaths<TSchema> | (string & {})>(path: TPath) => HasGetMethod<TSchema, TPath> extends true ? ReadPathMethods<TSchema, TPath, TDefaultError> : never;
+/**
+ * Mutation methods (non-GET).
+ */
+type MutationMethod = "POST" | "PUT" | "PATCH" | "DELETE";
+/**
+ * Write-only client type that only exposes mutation methods (POST, PUT, PATCH, DELETE).
+ * Used by useWrite/injectWrite hooks to ensure only mutation operations are selected.
+ */
+type WritePathMethods<TSchema, TPath extends string, TDefaultError> = FindMatchingKey<TSchema, TPath> extends infer TKey ? TKey extends keyof TSchema ? Simplify<{
+    [M in MutationMethod as M extends keyof TSchema[TKey] ? M : never]: M extends keyof TSchema[TKey] ? MethodFn<TSchema[TKey][M], TDefaultError, TPath> : never;
+}> : never : never;
+/**
+ * Check if a schema path has any mutation methods.
+ */
+type HasMutationMethod<TSchema, TPath extends string> = FindMatchingKey<TSchema, TPath> extends infer TKey ? TKey extends keyof TSchema ? MutationMethod extends never ? false : Extract<keyof TSchema[TKey], MutationMethod> extends never ? false : true : false : false;
+/**
+ * Extract paths that have mutation methods.
+ */
+type WritePaths<TSchema> = {
+    [K in keyof TSchema & string]: Extract<keyof TSchema[K], MutationMethod> extends never ? never : K;
+}[keyof TSchema & string];
+/**
+ * A write-only API client that only exposes mutation methods (POST, PUT, PATCH, DELETE).
+ * Used by useWrite and injectWrite hooks.
+ */
+type WriteClient<TSchema, TDefaultError = unknown> = <TPath extends WritePaths<TSchema> | (string & {})>(path: TPath) => HasMutationMethod<TSchema, TPath> extends true ? WritePathMethods<TSchema, TPath, TDefaultError> : never;
 
 type PluginArray = readonly SpooshPlugin<PluginTypeConfig>[];
 interface SpooshConfig<TPlugins extends PluginArray = PluginArray> {
@@ -925,7 +1059,7 @@ interface SpooshConfig<TPlugins extends PluginArray = PluginArray> {
     plugins?: TPlugins;
 }
 type SpooshInstance<TSchema = unknown, TDefaultError = unknown, TPlugins extends PluginArray = PluginArray> = {
-    api: SpooshClient<TSchema, TDefaultError, CoreRequestOptionsBase>;
+    api: SpooshClient<TSchema, TDefaultError>;
     stateManager: StateManager;
     eventEmitter: EventEmitter;
     pluginExecutor: PluginExecutor;
@@ -953,7 +1087,7 @@ type SpooshInstance<TSchema = unknown, TDefaultError = unknown, TPlugins extends
  *   .use([cachePlugin(), retryPlugin()]);
  *
  * const { api } = client;
- * const response = await api.posts.$get();
+ * const response = await api("posts").GET();
  * ```
  *
  * @example With default options
@@ -971,6 +1105,10 @@ type SpooshInstance<TSchema = unknown, TDefaultError = unknown, TPlugins extends
  *   .use([cachePlugin(), retryPlugin()]);
  *
  * const { useRead, useWrite } = createReactSpoosh(client);
+ *
+ * // In component
+ * const { data } = useRead((api) => api("posts").GET());
+ * const { trigger } = useWrite((api) => api("posts").POST);
  * ```
  *
  * @since 0.1.0
@@ -1056,16 +1194,16 @@ declare class Spoosh<TSchema = unknown, TError = unknown, TPlugins extends Plugi
      * const { api } = client;
      *
      * // GET request
-     * const { data } = await api.posts.$get();
+     * const { data } = await api("posts").GET();
      *
      * // POST request with body
-     * const { data } = await api.posts.$post({ body: { title: 'Hello' } });
+     * const { data } = await api("posts").POST({ body: { title: 'Hello' } });
      *
      * // Dynamic path parameters
-     * const { data } = await api.posts(postId).$get();
+     * const { data } = await api("posts/:id").GET({ params: { id: postId } });
      * ```
      */
-    get api(): SpooshClient<TSchema, TError, CoreRequestOptionsBase>;
+    get api(): SpooshClient<TSchema, TError>;
     /**
      * State manager for cache and state operations.
      *
@@ -1076,7 +1214,7 @@ declare class Spoosh<TSchema = unknown, TError = unknown, TPlugins extends Plugi
      * const { stateManager } = client;
      *
      * // Get cached data
-     * const cache = stateManager.getCache('posts.$get');
+     * const cache = stateManager.getCache('posts.GET');
      *
      * // Invalidate cache by tag
      * stateManager.invalidate(['posts']);
@@ -1162,16 +1300,17 @@ type SpooshClientConfig = {
  *
  * @example
  * ```ts
- * type ApiSchema = {
- *   posts: {
- *     $get: Endpoint<Post[]>;
- *     $post: Endpoint<Post, CreatePostBody>;
- *     _: {
- *       $get: Endpoint<Post>;
- *       $delete: Endpoint<void>;
- *     };
+ * type ApiSchema = SpooshSchema<{
+ *   "posts": {
+ *     GET: { data: Post[] };
+ *     POST: { data: Post; body: CreatePostBody };
  *   };
- * };
+ *   "posts/:id": {
+ *     GET: { data: Post };
+ *     PUT: { data: Post; body: UpdatePostBody };
+ *     DELETE: { data: void };
+ *   };
+ * }>;
  *
  * type ApiError = {
  *   message: string;
@@ -1181,9 +1320,10 @@ type SpooshClientConfig = {
  *   baseUrl: "/api",
  * });
  *
- * // Type-safe API calls
- * const { data } = await api.posts.$get();
- * const { data: post } = await api.posts(123).$get();
+ * // Type-safe API calls with path strings
+ * const { data } = await api("posts").GET();
+ * const { data: post } = await api("posts/123").GET();
+ * await api("posts/:id").GET({ params: { id: 123 } });
  * ```
  */
 declare function createClient<TSchema, TDefaultError = unknown>(config: SpooshClientConfig): SpooshClient<TSchema, TDefaultError>;
@@ -1208,6 +1348,11 @@ declare function mergeHeaders(defaultHeaders?: HeadersInitOrGetter, requestHeade
 declare function setHeaders(requestOptions: {
     headers?: HeadersInitOrGetter;
 }, newHeaders: Record<string, string>): void;
+/**
+ * Extracts the Content-Type header value from HeadersInit.
+ * Returns undefined if no Content-Type is set.
+ */
+declare function getContentType(headers?: HeadersInit): string | undefined;
 
 declare function objectToFormData(obj: Record<string, unknown>): FormData;
 
@@ -1215,14 +1360,21 @@ declare function objectToUrlEncoded(obj: Record<string, unknown>): string;
 
 declare function sortObjectKeys(obj: unknown, seen?: WeakSet<object>): unknown;
 
+type TagMode = "all" | "self" | "none";
+type TagModeInArray = "all" | "self";
 /**
  * Common tag options used across plugins and operations.
  */
 type TagOptions = {
-    /** Custom tags to use instead of auto-generated path-based tags */
-    tags?: string[];
-    /** Additional tags to append to auto-generated or custom tags */
-    additionalTags?: string[];
+    /**
+     * Unified tag option (follows invalidation pattern)
+     * - String: mode only ('all' | 'self' | 'none')
+     * - Array: custom tags only OR [mode keyword mixed with custom tags]
+     *   - If array contains 'all' or 'self', it's treated as mode + tags
+     *   - Otherwise, it's custom tags only (replaces auto-generated tags)
+     *   - 'none' keyword should NOT be used in arrays (use string 'none' instead)
+     */
+    tags?: TagMode | (TagModeInArray | (string & {}))[];
 };
 declare function resolveTags(options: TagOptions | undefined, resolvedPath: string[]): string[];
 declare function resolvePath(path: string[], params: Record<string, string | number> | undefined): string[];
@@ -1230,41 +1382,30 @@ declare function resolvePath(path: string[], params: Record<string, string | num
 type ProxyHandlerConfig<TOptions = SpooshOptions> = {
     baseUrl: string;
     defaultOptions: TOptions;
-    path?: string[];
     fetchExecutor?: FetchExecutor<TOptions, AnyRequestOptions>;
     nextTags?: boolean;
 };
 /**
- * Creates the real API client proxy that executes actual HTTP requests.
- *
- * This proxy intercepts property access and function calls to build URL paths,
- * then executes fetch requests when an HTTP method ($get, $post, etc.) is called.
- *
- * Used internally by `createClient` and `createSpoosh` to create typed API clients.
+ * Creates an API client proxy that uses path strings instead of chained property access.
+ * Methods use HTTP names directly: GET, POST, PUT, PATCH, DELETE.
  *
  * @param config - Proxy handler configuration
- *
- * @returns A proxy object typed as TSchema that executes real HTTP requests
+ * @returns A function that takes a path and returns an object with HTTP method functions
  *
  * @example
  * ```ts
  * const api = createProxyHandler<ApiSchema>({ baseUrl: '/api', defaultOptions: {} });
  *
- * // Accessing api.posts.$get() will:
- * // 1. Build path: ['posts']
- * // 2. Execute: GET /api/posts
- * await api.posts.$get();
- *
- * // Dynamic segments via function call:
- * // api.posts(123).$get() or api.posts('123').$get()
- * // Executes: GET /api/posts/123
- * await api.posts(123).$get();
+ * // Call with path string
+ * await api("posts").GET();
+ * await api("posts/123").GET();
+ * await api("posts/:id").GET({ params: { id: 123 } });
  * ```
  */
-declare function createProxyHandler<TSchema extends object, TOptions = SpooshOptions>(config: ProxyHandlerConfig<TOptions>): TSchema;
+declare function createProxyHandler<TSchema, TDefaultError = unknown, TOptions = SpooshOptions>(config: ProxyHandlerConfig<TOptions>): SpooshClient<TSchema, TDefaultError>;
 
 /** All supported HTTP method keys used in the API client */
-declare const HTTP_METHODS: readonly ["$get", "$post", "$put", "$patch", "$delete"];
+declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
 /** Union type of all HTTP method keys */
 type HttpMethodKey = (typeof HTTP_METHODS)[number];
 /**
@@ -1275,9 +1416,9 @@ type HttpMethodKey = (typeof HTTP_METHODS)[number];
 type SelectorFunction = (() => Promise<{
     data: undefined;
 }>) & {
-    /** The path segments leading to this endpoint (e.g., ['posts', 'comments']) */
-    __selectorPath?: string[];
-    /** The HTTP method selected (e.g., '$get', '$post') */
+    /** The path string for this endpoint (e.g., 'posts', 'posts/:id') */
+    __selectorPath?: string;
+    /** The HTTP method selected (e.g., 'GET', 'POST') */
     __selectorMethod?: string;
 };
 /**
@@ -1286,9 +1427,9 @@ type SelectorFunction = (() => Promise<{
  * Captured when an HTTP method is invoked with options.
  */
 type CapturedCall = {
-    /** Path segments to the endpoint (e.g., ['posts', ':id']) */
-    path: string[];
-    /** HTTP method called (e.g., '$get', '$post') */
+    /** Path string to the endpoint (e.g., 'posts/:id') */
+    path: string;
+    /** HTTP method called (e.g., 'GET', 'POST') */
     method: string;
     /** Request options passed to the method (query, body, params, etc.) */
     options: unknown;
@@ -1299,8 +1440,8 @@ type CapturedCall = {
  * Captured when an HTTP method is accessed but not yet called.
  */
 type SelectedEndpoint = {
-    /** Path segments to the endpoint */
-    path: string[];
+    /** Path string to the endpoint */
+    path: string;
     /** HTTP method selected */
     method: string;
 };
@@ -1330,41 +1471,41 @@ type SelectorResult = {
  * const proxy = createSelectorProxy<ApiSchema>();
  *
  * // Select an endpoint
- * const endpoint = proxy.posts.$get;
+ * const endpoint = proxy("posts").GET;
  *
  * // Extract path for cache operations
- * const path = extractPathFromSelector(endpoint); // ['posts']
- * const method = extractMethodFromSelector(endpoint); // '$get'
+ * const path = extractPathFromSelector(endpoint); // 'posts'
+ * const method = extractMethodFromSelector(endpoint); // 'GET'
  * ```
  *
  * @internal onCapture - Used internally by framework adapters
  */
 declare function createSelectorProxy<TSchema>(onCapture?: (result: SelectorResult) => void): TSchema;
 /**
- * Extracts the path segments from a SelectorFunction.
+ * Extracts the path from a SelectorFunction.
  *
  * @param fn - A SelectorFunction returned from `createSelectorProxy`
- * @returns Array of path segments (e.g., ['posts', 'comments'])
+ * @returns The path string (e.g., 'posts', 'posts/:id')
  *
  * @example
  * ```ts
  * const proxy = createSelectorProxy<ApiSchema>();
- * const path = extractPathFromSelector(proxy.posts.comments.$get);
- * // path = ['posts', 'comments']
+ * const path = extractPathFromSelector(proxy("posts").GET);
+ * // path = 'posts'
  * ```
  */
-declare function extractPathFromSelector(fn: unknown): string[];
+declare function extractPathFromSelector(fn: unknown): string;
 /**
  * Extracts the HTTP method from a SelectorFunction.
  *
  * @param fn - A SelectorFunction returned from `createSelectorProxy`
- * @returns The HTTP method string (e.g., '$get', '$post') or undefined
+ * @returns The HTTP method string (e.g., 'GET', 'POST') or undefined
  *
  * @example
  * ```ts
  * const proxy = createSelectorProxy<ApiSchema>();
- * const method = extractMethodFromSelector(proxy.posts.$post);
- * // method = '$post'
+ * const method = extractMethodFromSelector(proxy("posts").POST);
+ * // method = 'POST'
  * ```
  */
 declare function extractMethodFromSelector(fn: unknown): string | undefined;
@@ -1463,4 +1604,4 @@ type CreateInfiniteReadOptions<TData, TItem, TError, TRequest> = {
 };
 declare function createInfiniteReadController<TData, TItem, TError, TRequest extends InfiniteRequestOptions = InfiniteRequestOptions>(options: CreateInfiniteReadOptions<TData, TItem, TError, TRequest>): InfiniteReadController<TData, TItem, TError>;
 
-export { type AnyRequestOptions, type BuiltInEvents, type CacheEntry, type CacheEntryWithKey, type CapturedCall, type SpooshClientConfig as ClientConfig, type ComputeRequestOptions, type CoreRequestOptionsBase, type CreateInfiniteReadOptions, type CreateOperationOptions, type DataAwareCallback, type DataAwareTransform, type Endpoint, type EventEmitter, type ExtractBody, type ExtractData, type ExtractError, type ExtractFormData, type ExtractMethodDef, type ExtractMethodOptions, type ExtractQuery, type ExtractUrlEncoded, type FetchDirection, type FetchExecutor, HTTP_METHODS, type HasMethod, type HasQueryMethods, type HasRequiredOptions, type HeadersInitOrGetter, type HttpMethod, type HttpMethodKey, type InfiniteReadController, type InfiniteReadState, type InfiniteRequestOptions, type InstanceApiContext, type InstanceApiResolvers, type InstancePluginExecutor, type LifecyclePhase, type MergePluginInstanceApi, type MergePluginOptions, type MergePluginResults, type MethodFn, type MethodOptionsMap, type MiddlewareContext, type MiddlewareHandler, type MiddlewarePhase, type MutationOnlyClient, type NormalizeEndpoint, type OperationController, type OperationState, type OperationType, type PageContext, type PluginAccessor, type PluginArray, type PluginContext, type PluginContextInput, type PluginExecutor, type PluginExportsRegistry, type PluginFactory, type PluginHandler, type PluginLifecycle, type PluginMiddleware, type PluginRegistry, type PluginResolvers, type PluginResponseHandler, type PluginResultResolvers, type PluginTypeConfig, type PluginUpdateHandler, type QueryOnlyClient, type QuerySchemaHelper, type RefetchEvent, type RequestOptions, type ResolveInstanceApi, type ResolveResultTypes, type ResolveSchemaTypes, type ResolveTypes, type ResolverContext, type RetryConfig, type SchemaMethod, type SelectedEndpoint, type SelectorFunction, type SelectorResult, Spoosh, type SpooshClient, type SpooshConfig, type SpooshInstance, type SpooshMiddleware, type SpooshOptions, type SpooshOptionsExtra, type SpooshPlugin, type SpooshResponse, type StateManager, type StaticPathKeys, type TagOptions, applyMiddlewares, buildUrl, composeMiddlewares, containsFile, createClient, createEventEmitter, createInfiniteReadController, createInitialState, createMiddleware, createOperationController, createPluginExecutor, createPluginRegistry, createProxyHandler, createSelectorProxy, createStateManager, executeFetch, extractMethodFromSelector, extractPathFromSelector, generateTags, isJsonBody, mergeHeaders, objectToFormData, objectToUrlEncoded, resolveHeadersToRecord, resolvePath, resolveTags, setHeaders, sortObjectKeys };
+export { type AnyRequestOptions, type ApiSchema, type BuiltInEvents, type CacheEntry, type CacheEntryWithKey, type CapturedCall, type SpooshClientConfig as ClientConfig, type ComputeRequestOptions, type CoreRequestOptionsBase, type CreateInfiniteReadOptions, type CreateOperationOptions, type DataAwareCallback, type DataAwareTransform, type EventEmitter, type ExtractBody$1 as ExtractBody, type ExtractData, type ExtractError, type ExtractMethodOptions, type ExtractParamNames, type ExtractQuery$1 as ExtractQuery, type FetchDirection, type FetchExecutor, type FindMatchingKey, HTTP_METHODS, type HasParams, type HeadersInitOrGetter, type HttpMethod, type HttpMethodKey, type InfiniteReadController, type InfiniteReadState, type InfiniteRequestOptions, type InstanceApiContext, type InstanceApiResolvers, type InstancePluginExecutor, type LifecyclePhase, type MergePluginInstanceApi, type MergePluginOptions, type MergePluginResults, type MethodOptionsMap, type MiddlewareContext, type MiddlewareHandler, type MiddlewarePhase, type MutationSchemaHelper, type OperationController, type OperationState, type OperationType, type PageContext, type PluginAccessor, type PluginArray, type PluginContext, type PluginContextInput, type PluginExecutor, type PluginExportsRegistry, type PluginFactory, type PluginHandler, type PluginLifecycle, type PluginMiddleware, type PluginRegistry, type PluginResolvers, type PluginResponseHandler, type PluginResultResolvers, type PluginTypeConfig, type PluginUpdateHandler, type QuerySchemaHelper, type ReadClient, type RefetchEvent, type RequestOptions$1 as RequestOptions, type ResolveInstanceApi, type ResolveResultTypes, type ResolveSchemaTypes, type ResolveTypes, type ResolverContext, type RetryConfig, type RouteToPath, type SchemaPaths, type SelectedEndpoint, type SelectorFunction, type SelectorResult, Spoosh, type SpooshClient, type SpooshConfig, type SpooshInstance, type SpooshMiddleware, type SpooshOptions, type SpooshOptionsExtra, type SpooshPlugin, type SpooshResponse, type SpooshSchema, type StateManager, type TagMode, type TagOptions, type WriteClient, applyMiddlewares, buildUrl, composeMiddlewares, containsFile, createClient, createEventEmitter, createInfiniteReadController, createInitialState, createMiddleware, createOperationController, createPluginExecutor, createPluginRegistry, createProxyHandler, createSelectorProxy, createStateManager, executeFetch, extractMethodFromSelector, extractPathFromSelector, generateTags, getContentType, isJsonBody, mergeHeaders, objectToFormData, objectToUrlEncoded, resolveHeadersToRecord, resolvePath, resolveTags, setHeaders, sortObjectKeys };