@spoosh/core 0.10.0 → 0.11.0

package/README.md

@@ -1,6 +1,6 @@
 # @spoosh/core
 
-Core client and plugin system for Spoosh - a type-safe API client framework.
+Core client and plugin system for Spoosh - a type-safe API toolkit.
 
 **[Documentation](https://spoosh.dev/docs/react)** · **Requirements:** TypeScript >= 5.0
 
@@ -47,8 +47,11 @@ type ApiSchema = {
 ```typescript
 import { createClient } from "@spoosh/core";
 
-const api = createClient<ApiSchema>({
-  baseUrl: "/api",
+const api = createClient<ApiSchema>("/api");
+
+// With custom options
+const apiWithAuth = createClient<ApiSchema>("/api", {
+  headers: { Authorization: "Bearer token" },
 });
 
 // Import body wrappers for explicit serialization
@@ -115,7 +118,7 @@ When using `createClient`, Next.js cache tags are automatically generated from t
 // Server component
 import { createClient } from "@spoosh/core";
 
-const api = createClient<ApiSchema>({ baseUrl: process.env.API_URL! });
+const api = createClient<ApiSchema>(process.env.API_URL!);
 
 // Auto-generates next: { tags: ['posts'] }
 const { data: posts } = await api("posts").GET();
@@ -128,51 +131,6 @@ const { data: userPosts } = await api("users/:id/posts").GET({
 
 This enables automatic cache invalidation with `revalidateTag()` in Next.js.
 
-### With Middlewares
-
-```typescript
-import { createClient, createMiddleware } from "@spoosh/core";
-
-const authMiddleware = createMiddleware("auth", "before", async (ctx) => {
-  ctx.requestOptions = {
-    ...ctx.requestOptions,
-    headers: { Authorization: `Bearer ${token}` },
-  };
-  return ctx;
-});
-
-const api = createClient<ApiSchema>({
-  baseUrl: "/api",
-  middlewares: [authMiddleware],
-});
-```
-
-### Middleware Utilities
-
-```typescript
-import {
-  createMiddleware,
-  applyMiddlewares,
-  composeMiddlewares,
-} from "@spoosh/core";
-
-// createMiddleware(name, phase, handler) - Create a named middleware
-const logMiddleware = createMiddleware("logger", "after", async (ctx) => {
-  console.log(ctx.response?.status);
-  return ctx;
-});
-
-// composeMiddlewares(...lists) - Combine multiple middleware arrays
-const allMiddlewares = composeMiddlewares(
-  [authMiddleware],
-  [logMiddleware],
-  conditionalMiddlewares
-);
-
-// applyMiddlewares(context, middlewares, phase) - Run middlewares for a phase
-const updatedContext = await applyMiddlewares(context, middlewares, "before");
-```
-
 ## Schema Types
 
 | Field   | Description           | Example                                          |
@@ -186,15 +144,16 @@ Path parameters are defined using `:param` syntax in the path key (e.g., `"users
 
 ## API Reference
 
-### createClient(config)
+### createClient(baseUrl, defaultOptions?)
+
+Creates a lightweight type-safe API instance.
 
-Creates a lightweight type-safe API client.
+**Parameters:**
 
-| Option           | Type                 | Description                                        |
-| ---------------- | -------------------- | -------------------------------------------------- |
-| `baseUrl`        | `string`             | Base URL for all API requests                      |
-| `defaultOptions` | `RequestInit`        | Default fetch options (headers, credentials, etc.) |
-| `middlewares`    | `SpooshMiddleware[]` | Request/response middlewares                       |
+| Parameter        | Type          | Description                                                   |
+| ---------------- | ------------- | ------------------------------------------------------------- |
+| `baseUrl`        | `string`      | Base URL for all API requests                                 |
+| `defaultOptions` | `RequestInit` | (Optional) Default fetch options (headers, credentials, etc.) |
 
 ### Spoosh (class)
 
@@ -228,12 +187,12 @@ const { data } = await api("users").GET();
 
 **Properties:**
 
-| Property          | Description                              |
-| ----------------- | ---------------------------------------- |
-| `.api`            | Type-safe API client for making requests |
-| `.stateManager`   | Cache and state management               |
-| `.eventEmitter`   | Event system for refetch/invalidation    |
-| `.pluginExecutor` | Plugin lifecycle management              |
+| Property          | Description                                 |
+| ----------------- | ------------------------------------------- |
+| `.api`            | Type-safe API interface for making requests |
+| `.stateManager`   | Cache and state management                  |
+| `.eventEmitter`   | Event system for refetch/invalidation       |
+| `.pluginExecutor` | Plugin lifecycle management                 |
 
 ## Creating Plugins
 

package/dist/index.d.mts

@@ -4,24 +4,6 @@ type Simplify<T> = {
     [K in keyof T]: T[K];
 } & {};
 
-type MiddlewarePhase = "before" | "after";
-type MiddlewareContext<TData = unknown, TError = unknown> = {
-    baseUrl: string;
-    path: string[];
-    method: HttpMethod;
-    defaultOptions: SpooshOptions & SpooshOptionsExtra;
-    requestOptions?: AnyRequestOptions;
-    fetchInit?: RequestInit;
-    response?: SpooshResponse<TData, TError>;
-    metadata: Record<string, unknown>;
-};
-type MiddlewareHandler<TData = unknown, TError = unknown> = (context: MiddlewareContext<TData, TError>) => MiddlewareContext<TData, TError> | Promise<MiddlewareContext<TData, TError>>;
-type SpooshMiddleware<TData = unknown, TError = unknown> = {
-    name: string;
-    phase: MiddlewarePhase;
-    handler: MiddlewareHandler<TData, TError>;
-};
-
 type QueryField<TQuery> = [TQuery] extends [never] ? object : {
     query: TQuery;
 };
@@ -54,15 +36,25 @@ type SpooshResponse<TData, TError, TRequestOptions = unknown, TQuery = never, TB
     aborted?: boolean;
     readonly __requestOptions?: TRequestOptions;
 } & InputFieldWrapper<TQuery, TBody, TParamNames>);
-type SpooshOptionsExtra<TData = unknown, TError = unknown> = {
-    middlewares?: SpooshMiddleware<TData, TError>[];
-};
 
-type SpooshBody<T = unknown> = {
-    readonly __spooshBody: true;
-    readonly kind: "form" | "json" | "urlencoded";
-    readonly value: T;
-};
+/**
+ * Opaque type representing a transformed body. Create using `form()`, `json()`, or `urlencoded()` helpers.
+ * Do not create this type manually - use the helper functions instead.
+ *
+ * @example
+ * ```ts
+ * import { form, json, urlencoded } from "@spoosh/core";
+ *
+ * // Use helpers to create SpooshBody
+ * trigger({ body: form({ file: myFile }) });
+ * trigger({ body: json({ data: "value" }) });
+ * trigger({ body: urlencoded({ key: "value" }) });
+ * ```
+ */
+declare class SpooshBodyClass<T> {
+    private __brand;
+}
+type SpooshBody<T = unknown> = SpooshBodyClass<T>;
 declare function isSpooshBody(value: unknown): value is SpooshBody;
 declare function form<T>(value: T): SpooshBody<T>;
 declare function json<T>(value: T): SpooshBody<T>;
@@ -231,7 +223,7 @@ type CacheEntryWithKey<TData = unknown, TError = unknown> = {
 declare function createInitialState<TData, TError>(): OperationState<TData, TError>;
 type StateManager = {
     createQueryKey: (params: {
-        path: string[];
+        path: string;
         method: string;
         options?: unknown;
     }) => string;
@@ -249,6 +241,8 @@ type StateManager = {
     getAllCacheEntries: <TData, TError>() => CacheEntryWithKey<TData, TError>[];
     /** Get the number of cache entries */
     getSize: () => number;
+    /** Get the number of active subscribers for a cache key */
+    getSubscribersCount: (key: string) => number;
     /** Set a pending promise for a query key (for deduplication) */
     setPendingPromise: (key: string, promise: Promise<unknown> | undefined) => void;
     /** Get a pending promise for a query key */
@@ -275,9 +269,13 @@ type CacheEntry<TData = unknown, TError = unknown> = {
     /** Cache was invalidated while no subscriber was listening. Triggers refetch on next mount. */
     stale?: boolean;
 };
-type PluginContext<TData = unknown, TError = unknown> = {
+/** RequestOptions in plugin context have headers already resolved to Record */
+type PluginRequestOptions = Omit<AnyRequestOptions, "headers"> & {
+    headers: Record<string, string>;
+};
+type PluginContext = {
     readonly operationType: OperationType;
-    readonly path: string[];
+    readonly path: string;
     readonly method: HttpMethod;
     readonly queryKey: string;
     readonly tags: string[];
@@ -285,17 +283,10 @@ type PluginContext<TData = unknown, TError = unknown> = {
     readonly requestTimestamp: number;
     /** Unique identifier for the hook instance. Persists across queryKey changes within the same hook. */
     readonly hookId?: string;
-    requestOptions: AnyRequestOptions;
-    state: OperationState<TData, TError>;
-    response?: SpooshResponse<TData, TError>;
+    request: PluginRequestOptions;
     metadata: Map<string, unknown>;
-    abort: () => void;
     stateManager: StateManager;
     eventEmitter: EventEmitter;
-    /** Resolved headers as a plain object. Modify via setHeaders(). */
-    headers: Record<string, string>;
-    /** Add/update headers. Merges with existing headers. */
-    setHeaders: (headers: Record<string, string>) => void;
     /** Access other plugins' exported APIs */
     plugins: PluginAccessor;
     /** Plugin-specific options passed from hooks (useRead/useWrite/useInfiniteRead) */
@@ -304,7 +295,7 @@ type PluginContext<TData = unknown, TError = unknown> = {
     forceRefetch?: boolean;
 };
 /** Input type for creating PluginContext (without injected properties) */
-type PluginContextInput<TData = unknown, TError = unknown> = Omit<PluginContext<TData, TError>, "plugins" | "setHeaders" | "headers">;
+type PluginContextInput = Omit<PluginContext, "plugins">;
 /**
  * Middleware function that wraps the fetch flow.
  * Plugins use this for full control over request/response handling.
@@ -334,22 +325,22 @@ type PluginContextInput<TData = unknown, TError = unknown> = Omit<PluginContext<
  * }
  * ```
  */
-type PluginMiddleware<TData = unknown, TError = unknown> = (context: PluginContext<TData, TError>, next: () => Promise<SpooshResponse<TData, TError>>) => Promise<SpooshResponse<TData, TError>>;
-type PluginHandler<TData = unknown, TError = unknown> = (context: PluginContext<TData, TError>) => void | Promise<void>;
-type PluginUpdateHandler<TData = unknown, TError = unknown> = (context: PluginContext<TData, TError>, previousContext: PluginContext<TData, TError>) => void | Promise<void>;
+type PluginMiddleware = (context: PluginContext, next: () => Promise<SpooshResponse<any, any>>) => Promise<SpooshResponse<any, any>>;
+type PluginHandler = (context: PluginContext) => void | Promise<void>;
+type PluginUpdateHandler = (context: PluginContext, previousContext: PluginContext) => void | Promise<void>;
 /**
  * Handler called after every response, regardless of early returns from middleware.
  * Can return a new response to transform it, or void for side effects only.
  * Returned responses are chained through plugins in order.
  */
-type PluginResponseHandler<TData = unknown, TError = unknown> = (context: PluginContext<TData, TError>, response: SpooshResponse<TData, TError>) => SpooshResponse<TData, TError> | void | Promise<SpooshResponse<TData, TError> | void>;
-type PluginLifecycle<TData = unknown, TError = unknown> = {
+type PluginResponseHandler = (context: PluginContext, response: SpooshResponse<any, any>) => SpooshResponse<any, any> | void | Promise<SpooshResponse<any, any> | void>;
+type PluginLifecycle = {
     /** Called on component mount */
-    onMount?: PluginHandler<TData, TError>;
+    onMount?: PluginHandler;
     /** Called when options/query changes. Receives both new and previous context. */
-    onUpdate?: PluginUpdateHandler<TData, TError>;
+    onUpdate?: PluginUpdateHandler;
     /** Called on component unmount */
-    onUnmount?: PluginHandler<TData, TError>;
+    onUnmount?: PluginHandler;
 };
 /**
  * Configuration object for plugin type definitions.
@@ -606,8 +597,8 @@ type RefetchEvent = {
  * Avoids circular dependency with executor.ts.
  */
 type InstancePluginExecutor = {
-    executeMiddleware: <TData, TError>(operationType: OperationType, context: PluginContext<TData, TError>, coreFetch: () => Promise<SpooshResponse<TData, TError>>) => Promise<SpooshResponse<TData, TError>>;
-    createContext: <TData, TError>(input: PluginContextInput<TData, TError>) => PluginContext<TData, TError>;
+    executeMiddleware: <TData, TError>(operationType: OperationType, context: PluginContext, coreFetch: () => Promise<SpooshResponse<any, any>>) => Promise<SpooshResponse<TData, TError>>;
+    createContext: (input: PluginContextInput) => PluginContext;
 };
 /**
  * Context provided to plugin's instanceApi function.
@@ -622,14 +613,13 @@ type InstanceApiContext<TApi = unknown> = {
 
 type PluginExecutor = {
     /** Execute lifecycle hooks for onMount or onUnmount */
-    executeLifecycle: <TData, TError>(phase: "onMount" | "onUnmount", operationType: OperationType, context: PluginContext<TData, TError>) => Promise<void>;
+    executeLifecycle: (phase: "onMount" | "onUnmount", operationType: OperationType, context: PluginContext) => Promise<void>;
     /** Execute onUpdate lifecycle with previous context */
-    executeUpdateLifecycle: <TData, TError>(operationType: OperationType, context: PluginContext<TData, TError>, previousContext: PluginContext<TData, TError>) => Promise<void>;
-    /** Execute middleware chain with a core fetch function, then run afterResponse handlers */
-    executeMiddleware: <TData, TError>(operationType: OperationType, context: PluginContext<TData, TError>, coreFetch: () => Promise<SpooshResponse<TData, TError>>) => Promise<SpooshResponse<TData, TError>>;
+    executeUpdateLifecycle: (operationType: OperationType, context: PluginContext, previousContext: PluginContext) => Promise<void>;
+    executeMiddleware: (operationType: OperationType, context: PluginContext, coreFetch: () => Promise<SpooshResponse<any, any>>) => Promise<SpooshResponse<any, any>>;
     getPlugins: () => readonly SpooshPlugin[];
     /** Creates a full PluginContext with plugins accessor injected */
-    createContext: <TData, TError>(input: PluginContextInput<TData, TError>) => PluginContext<TData, TError>;
+    createContext: (input: PluginContextInput) => PluginContext;
 };
 declare function createPluginExecutor(initialPlugins?: SpooshPlugin[]): PluginExecutor;
 
@@ -1060,7 +1050,7 @@ type PathMethods<TSchema, TPath extends string, TDefaultError> = FindMatchingKey
  */
 type SchemaPaths<TSchema> = keyof TSchema & string;
 /**
- * An API client that uses path strings instead of chained property access.
+ * An API interface that uses path strings instead of chained property access.
  * Methods use HTTP names directly: GET, POST, PUT, PATCH, DELETE.
  *
  * @example
@@ -1091,7 +1081,7 @@ type ReadPathMethods<TSchema, TPath extends string, TDefaultError> = FindMatchin
     GET: MethodFn<TSchema[TKey]["GET"], TDefaultError, TPath>;
 }> : never : never : never;
 /**
- * A read-only API client that only exposes GET methods.
+ * A read-only API interface that only exposes GET methods.
  * Used by useRead and injectRead hooks.
  */
 type ReadClient<TSchema, TDefaultError = unknown> = <TPath extends ReadPaths<TSchema> | (string & {})>(path: TPath) => HasReadMethod<TSchema, TPath> extends true ? ReadPathMethods<TSchema, TPath, TDefaultError> : never;
@@ -1103,7 +1093,7 @@ type WritePathMethods<TSchema, TPath extends string, TDefaultError> = FindMatchi
     [M in WriteMethod as M extends keyof TSchema[TKey] ? M : never]: M extends keyof TSchema[TKey] ? MethodFn<TSchema[TKey][M], TDefaultError, TPath> : never;
 }> : never : never;
 /**
- * A write-only API client that only exposes mutation methods (POST, PUT, PATCH, DELETE).
+ * A write-only API interface 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) => HasWriteMethod<TSchema, TPath> extends true ? WritePathMethods<TSchema, TPath, TDefaultError> : never;
@@ -1246,7 +1236,7 @@ declare class Spoosh<TSchema = unknown, TError = unknown, TPlugins extends Plugi
      */
     private getInstance;
     /**
-     * The type-safe API client for making requests.
+     * The type-safe API interface for making requests.
      *
      * Provides a proxy-based interface for accessing endpoints defined in your schema.
      *
@@ -1346,19 +1336,15 @@ declare class Spoosh<TSchema = unknown, TError = unknown, TPlugins extends Plugi
     };
 }
 
-type SpooshClientConfig = {
-    baseUrl: string;
-    defaultOptions?: SpooshOptionsInput;
-    middlewares?: SpooshMiddleware[];
-};
 /**
- * Creates a lightweight type-safe API client for vanilla JavaScript/TypeScript usage.
+ * Creates a lightweight type-safe API instance for vanilla JavaScript/TypeScript usage.
  *
  * This is a simpler alternative to `Spoosh` for users who don't need
  * the full plugin system, state management, or React integration.
  *
- * @param config - Client configuration
- * @returns Type-safe API client
+ * @param baseUrl - Base URL for all API requests
+ * @param defaultOptions - Default fetch options (headers, credentials, etc.)
+ * @returns Type-safe API instance
  *
  * @example
  * ```ts
@@ -1378,23 +1364,21 @@ type SpooshClientConfig = {
  *   message: string;
  * }
  *
- * const api = createClient<ApiSchema, ApiError>({
- *   baseUrl: "/api",
- * });
+ * const api = createClient<ApiSchema, ApiError>("/api");
  *
  * // 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 } });
  *
- * // With XHR transport
- * const api = createClient<ApiSchema, ApiError>({
- *   baseUrl: "/api",
- *   defaultOptions: { transport: "xhr" },
+ * // With custom options
+ * const api = createClient<ApiSchema, ApiError>("/api", {
+ *   headers: { Authorization: "Bearer token" },
+ *   transport: "xhr",
  * });
  * ```
  */
-declare function createClient<TSchema, TDefaultError = unknown>(config: SpooshClientConfig): SpooshClient<TSchema, TDefaultError>;
+declare function createClient<TSchema, TDefaultError = unknown>(baseUrl: string, defaultOptions?: SpooshOptionsInput): SpooshClient<TSchema, TDefaultError>;
 
 declare function buildUrl(baseUrl: string, path: string[], query?: Record<string, string | number | boolean | undefined>): string;
 
@@ -1456,7 +1440,7 @@ type ProxyHandlerConfig<TOptions = SpooshOptions> = {
     nextTags?: boolean;
 };
 /**
- * Creates an API client proxy that uses path strings instead of chained property access.
+ * Creates an API 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
@@ -1474,7 +1458,7 @@ type ProxyHandlerConfig<TOptions = SpooshOptions> = {
  */
 declare function createProxyHandler<TSchema, TDefaultError = unknown, TOptions = SpooshOptions>(config: ProxyHandlerConfig<TOptions>): SpooshClient<TSchema, TDefaultError>;
 
-/** All supported HTTP method keys used in the API client */
+/** All supported HTTP method keys used in the API toolkit */
 declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
 /** Union type of all HTTP method keys */
 type HttpMethodKey = (typeof HTTP_METHODS)[number];
@@ -1593,11 +1577,7 @@ declare module "./types" {
 }
 declare const xhrTransport: Transport<XhrTransportOptions>;
 
-declare function executeFetch<TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: SpooshOptions & SpooshOptionsExtra, requestOptions?: AnyRequestOptions, nextTags?: boolean): Promise<SpooshResponse<TData, TError>>;
-
-declare function createMiddleware<TData = unknown, TError = unknown>(name: string, phase: MiddlewarePhase, handler: SpooshMiddleware<TData, TError>["handler"]): SpooshMiddleware<TData, TError>;
-declare function applyMiddlewares<TData = unknown, TError = unknown>(context: MiddlewareContext<TData, TError>, middlewares: SpooshMiddleware<TData, TError>[], phase: MiddlewarePhase): Promise<MiddlewareContext<TData, TError>>;
-declare function composeMiddlewares<TData = unknown, TError = unknown>(...middlewareLists: (SpooshMiddleware<TData, TError>[] | undefined)[]): SpooshMiddleware<TData, TError>[];
+declare function executeFetch<TData, TError>(baseUrl: string, path: string[], method: HttpMethod, defaultOptions: SpooshOptions, requestOptions?: AnyRequestOptions, nextTags?: boolean): Promise<SpooshResponse<TData, TError>>;
 
 type ExecuteOptions = {
     force?: boolean;
@@ -1613,15 +1593,15 @@ type OperationController<TData = unknown, TError = unknown> = {
     /** Called once when hook finally unmounts */
     unmount: () => void;
     /** Called when options/query changes. Pass previous context for cleanup. */
-    update: (previousContext: PluginContext<TData, TError>) => void;
+    update: (previousContext: PluginContext) => void;
     /** Get current context (for passing to update as previousContext) */
-    getContext: () => PluginContext<TData, TError>;
+    getContext: () => PluginContext;
     setPluginOptions: (options: unknown) => void;
     setMetadata: (key: string, value: unknown) => void;
 };
 type CreateOperationOptions<TData, TError> = {
     operationType: OperationType;
-    path: string[];
+    path: string;
     method: HttpMethod;
     tags: string[];
     requestOptions?: AnyRequestOptions;
@@ -1663,12 +1643,12 @@ type InfiniteReadController<TData, TItem, TError> = {
     abort: () => void;
     mount: () => void;
     unmount: () => void;
-    update: (previousContext: PluginContext<TData, TError>) => void;
-    getContext: () => PluginContext<TData, TError>;
+    update: (previousContext: PluginContext) => void;
+    getContext: () => PluginContext;
     setPluginOptions: (options: unknown) => void;
 };
 type CreateInfiniteReadOptions<TData, TItem, TError, TRequest> = {
-    path: string[];
+    path: string;
     method: HttpMethod;
     tags: string[];
     initialRequest: InfiniteRequestOptions;
@@ -1687,4 +1667,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 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 HasReadMethod, type HasWriteMethod, 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 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 ReadClient, type ReadPaths, type ReadSchemaHelper, type RefetchEvent, type RequestOptions$1 as RequestOptions, type ResolveInstanceApi, type ResolveResultTypes, type ResolveSchemaTypes, type ResolveTypes, type ResolverContext, type RetryConfig, type SchemaPaths, type SelectedEndpoint, type SelectorFunction, type SelectorResult, type Simplify, Spoosh, type SpooshBody, type SpooshClient, type SpooshConfig, type SpooshInstance, type SpooshMiddleware, type SpooshOptions, type SpooshOptionsExtra, type SpooshOptionsInput, type SpooshPlugin, type SpooshResponse, type SpooshSchema, type StateManager, type StripPrefix, type TagMode, type TagOptions, type Transport, type TransportOption, type TransportOptionsMap, type TransportResponse, type WriteClient, type WriteMethod, type WritePaths, type WriteSchemaHelper, __DEV__, applyMiddlewares, buildUrl, composeMiddlewares, containsFile, createClient, createEventEmitter, createInfiniteReadController, createInitialState, createMiddleware, createOperationController, createPluginExecutor, createPluginRegistry, createProxyHandler, createSelectorProxy, createStateManager, executeFetch, extractMethodFromSelector, extractPathFromSelector, fetchTransport, form, generateTags, getContentType, isJsonBody, isSpooshBody, json, mergeHeaders, objectToFormData, objectToUrlEncoded, resolveHeadersToRecord, resolvePath, resolveRequestBody, resolveTags, setHeaders, sortObjectKeys, urlencoded, xhrTransport };
+export { type AnyRequestOptions, type ApiSchema, type BuiltInEvents, type CacheEntry, type CacheEntryWithKey, type CapturedCall, 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 HasReadMethod, type HasWriteMethod, 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 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 PluginRequestOptions, type PluginResolvers, type PluginResponseHandler, type PluginResultResolvers, type PluginTypeConfig, type PluginUpdateHandler, type ReadClient, type ReadPaths, type ReadSchemaHelper, type RefetchEvent, type RequestOptions$1 as RequestOptions, type ResolveInstanceApi, type ResolveResultTypes, type ResolveSchemaTypes, type ResolveTypes, type ResolverContext, type RetryConfig, type SchemaPaths, type SelectedEndpoint, type SelectorFunction, type SelectorResult, type Simplify, Spoosh, type SpooshBody, type SpooshClient, type SpooshConfig, type SpooshInstance, type SpooshOptions, type SpooshOptionsInput, type SpooshPlugin, type SpooshResponse, type SpooshSchema, type StateManager, type StripPrefix, type TagMode, type TagOptions, type Transport, type TransportOption, type TransportOptionsMap, type TransportResponse, type WriteClient, type WriteMethod, type WritePaths, type WriteSchemaHelper, __DEV__, buildUrl, containsFile, createClient, createEventEmitter, createInfiniteReadController, createInitialState, createOperationController, createPluginExecutor, createPluginRegistry, createProxyHandler, createSelectorProxy, createStateManager, executeFetch, extractMethodFromSelector, extractPathFromSelector, fetchTransport, form, generateTags, getContentType, isJsonBody, isSpooshBody, json, mergeHeaders, objectToFormData, objectToUrlEncoded, resolveHeadersToRecord, resolvePath, resolveRequestBody, resolveTags, setHeaders, sortObjectKeys, urlencoded, xhrTransport };