@fragno-dev/api-fragment 0.0.0-stage → 0.0.1

package/dist/browser/client-DQE0c7GI.d.ts

@@ -0,0 +1,711 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region ../fragno/dist/api/internal/path.d.ts
+//#region src/api/internal/path.d.ts
+type SplitPath<T extends string> = T extends `${infer First}/${infer Rest}` ? First extends "" ? SplitPath<Rest> : [First, ...SplitPath<Rest>] : T extends "" ? [] : [T];
+type ExtractParam<T extends string> = T extends `:${infer Name}` ? Name : T extends `**:${infer Name}` ? Name : T extends "**" ? "**" : never;
+type ExtractParamsFromSegments<T extends readonly string[]> = T extends readonly [infer First, ...infer Rest] ? First extends string ? Rest extends readonly string[] ? ExtractParam<First> | ExtractParamsFromSegments<Rest> : ExtractParam<First> : never : never;
+/**
+ * Type helper to extract path parameters from a const string path
+ *
+ * Supports:
+ * - Regular paths: "/path" -> never
+ * - Named parameters: "/path/:name" -> "name"
+ * - Wildcard paths: "/path/foo/**" -> "**"
+ * - Named wildcard paths: "/path/foo/**:name" -> "name"
+ * - String (narrows): string -> never
+ */
+type ExtractPathParams<T extends string, ValueType = string> = ExtractParamsFromSegments<SplitPath<T>> extends never ? Record<string, never> : Record<ExtractParamsFromSegments<SplitPath<T>>, ValueType>;
+/**
+ * Same as @see ExtractPathParams, but returns `Record<string, ValueType>` when a string is
+ * passed in.
+ */
+type ExtractPathParamsOrWiden<T extends string, ValueType = string> = string extends T ? Record<string, ValueType> : ExtractPathParams<T, ValueType>;
+/**
+ * Same as @see ExtractPathParamsOrWiden, but returns `undefined` when no path parameters in the
+ * const.
+ */
+type MaybeExtractPathParamsOrWiden<T extends string, ValueType = string> = HasPathParams<T> extends true ? ExtractPathParamsOrWiden<T, ValueType> : undefined;
+type ExtractPathParamNames<T extends string> = ExtractParamsFromSegments<SplitPath<T>>;
+type HasPathParams<T extends string> = ExtractPathParamNames<T> extends never ? false : true;
+/**
+ * Creates a query parameters type where the specified keys are hints (optional)
+ * and additional string keys are also allowed.
+ *
+ * This allows for flexible query parameter typing where:
+ * - All hinted parameters are optional
+ * - Additional parameters beyond the hints are allowed
+ * - Values can be of any specified type (defaults to string)
+ *
+ * @example
+ * ```ts
+ * type MyQuery = QueryParamsHint<"page" | "limit", string>;
+ * // Allows: { page?: string, limit?: string, [key: string]: string }
+ *
+ * const query1: MyQuery = {}; // Valid - no params required
+ * const query2: MyQuery = { page: "1" }; // Valid - hinted param
+ * const query3: MyQuery = { page: "1", sort: "asc" }; // Valid - additional param
+ * ```
+ */
+type QueryParamsHint<TQueryParameters extends string, ValueType = string> = Partial<Record<TQueryParameters, ValueType>> & Record<string, ValueType | undefined>;
+//#endregion
+//#region ../fragno/dist/util/types-util.d.ts
+//#region src/util/types-util.d.ts
+type InferOr<T, U> = T extends NonNullable<StandardSchemaV1> ? StandardSchemaV1.InferOutput<T> : T extends undefined ? U : U;
+type InferOrUnknown<T> = InferOr<T, unknown>;
+//#endregion
+//#region ../fragno/dist/api/mutable-request-state.d.ts
+//#region src/api/mutable-request-state.d.ts
+/**
+ * Holds mutable request state that can be modified by middleware and consumed by handlers.
+ *
+ * This class provides a structural way for middleware to modify request data:
+ * - Path parameters can be modified
+ * - Query/search parameters can be modified
+ * - Request body can be overridden
+ * - Request headers can be modified
+ *
+ * @example
+ * ```typescript
+ * // In middleware
+ * const state = new MutableRequestState({
+ *   pathParams: { id: "123" },
+ *   searchParams: new URLSearchParams("?role=user"),
+ *   body: { name: "John" },
+ *   headers: new Headers()
+ * });
+ *
+ * // Modify query parameters
+ * state.searchParams.set("role", "admin");
+ *
+ * // Override body
+ * state.setBody({ name: "Jane" });
+ *
+ * // Modify headers
+ * state.headers.set("X-Custom", "value");
+ * ```
+ */
+declare class MutableRequestState {
+  #private;
+  constructor(config: {
+    pathParams: Record<string, string>;
+    searchParams: URLSearchParams;
+    body: unknown;
+    headers: Headers;
+  });
+  /**
+   * Path parameters extracted from the route.
+   * Can be modified directly (e.g., `state.pathParams.id = "456"`).
+   */
+  get pathParams(): Record<string, string>;
+  /**
+   * URLSearchParams for query parameters.
+   * Can be modified using URLSearchParams API (e.g., `state.searchParams.set("key", "value")`).
+   */
+  get searchParams(): URLSearchParams;
+  /**
+   * Request headers.
+   * Can be modified using Headers API (e.g., `state.headers.set("X-Custom", "value")`).
+   */
+  get headers(): Headers;
+  /**
+   * Get the current body value.
+   * Returns the override if set, otherwise the initial body.
+   */
+  get body(): unknown;
+  /**
+   * Override the request body.
+   * This allows middleware to replace the body that will be seen by the handler.
+   *
+   * @param body - The new body value
+   *
+   * @example
+   * ```typescript
+   * // In middleware
+   * state.setBody({ modifiedField: "new value" });
+   * ```
+   */
+  setBody(body: unknown): void;
+  /**
+   * Check if the body has been overridden by middleware.
+   */
+  get hasBodyOverride(): boolean;
+}
+//#endregion
+//#region ../fragno/dist/api/request-input-context.d.ts
+//#region src/api/request-input-context.d.ts
+type ValidatedInputContext<TInputSchema extends StandardSchemaV1 | undefined> = TInputSchema extends undefined ? undefined : {
+  schema: TInputSchema;
+  valid: () => Promise<TInputSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TInputSchema> : unknown>;
+};
+declare class RequestInputContext<TPath extends string = string, TInputSchema extends StandardSchemaV1 | undefined = undefined> {
+  #private;
+  constructor(config: {
+    path: TPath;
+    method: string;
+    pathParams: ExtractPathParams<TPath>;
+    searchParams: URLSearchParams;
+    parsedBody: unknown;
+    rawBody?: string;
+    headers: Headers;
+    request?: Request;
+    inputSchema?: TInputSchema;
+    shouldValidateInput?: boolean;
+  });
+  /**
+   * Create a RequestContext from a Request object for server-side handling
+   */
+  static fromRequest<TPath extends string, TInputSchema extends StandardSchemaV1 | undefined = undefined>(config: {
+    request: Request;
+    method: string;
+    path: TPath;
+    pathParams: ExtractPathParams<TPath>;
+    inputSchema?: TInputSchema;
+    shouldValidateInput?: boolean;
+    state: MutableRequestState;
+    rawBody?: string;
+  }): Promise<RequestInputContext<TPath, TInputSchema>>;
+  /**
+   * Create a RequestContext for server-side rendering contexts (no Request object)
+   */
+  static fromSSRContext<TPath extends string, TInputSchema extends StandardSchemaV1 | undefined = undefined>(config: {
+    method: "GET";
+    path: TPath;
+    pathParams: ExtractPathParams<TPath>;
+    searchParams?: URLSearchParams;
+    headers?: Headers;
+  } | {
+    method: Exclude<HTTPMethod, "GET">;
+    path: TPath;
+    pathParams: ExtractPathParams<TPath>;
+    searchParams?: URLSearchParams;
+    headers?: Headers;
+    body: unknown;
+    inputSchema?: TInputSchema;
+  }): RequestInputContext<TPath, TInputSchema>;
+  /**
+   * The HTTP method as string (e.g., `GET`, `POST`)
+   */
+  get method(): string;
+  /**
+   * The matched route path (e.g., `/users/:id`)
+   * @remarks `string`
+   */
+  get path(): TPath;
+  /**
+   * Extracted path parameters as object (e.g., `{ id: '123' }`)
+   * @remarks `Record<string, string>`
+   */
+  get pathParams(): ExtractPathParams<TPath>;
+  /**
+   * [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) object for query parameters
+   * @remarks `URLSearchParams`
+   */
+  get query(): URLSearchParams;
+  /**
+   * [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers) object for request headers
+   * @remarks `Headers`
+   */
+  get headers(): Headers;
+  get rawBody(): string | undefined;
+  get request(): Request | undefined;
+  /**
+   * Access the request body as FormData.
+   *
+   * Use this method when handling file uploads or multipart form submissions.
+   * The request must have been sent with Content-Type: multipart/form-data.
+   *
+   * @throws Error if the request body is not FormData
+   *
+   * @example
+   * ```typescript
+   * defineRoute({
+   *   method: "POST",
+   *   path: "/upload",
+   *   async handler(ctx, res) {
+   *     const formData = ctx.formData();
+   *     const file = formData.get("file") as File;
+   *     const description = formData.get("description") as string;
+   *     // ... process file
+   *   }
+   * });
+   * ```
+   */
+  formData(): FormData;
+  /**
+   * Check if the request body is FormData.
+   *
+   * Useful for routes that accept both JSON and FormData payloads.
+   *
+   * @example
+   * ```typescript
+   * defineRoute({
+   *   method: "POST",
+   *   path: "/upload",
+   *   async handler(ctx, res) {
+   *     if (ctx.isFormData()) {
+   *       const formData = ctx.formData();
+   *       // handle file upload
+   *     } else {
+   *       const json = await ctx.input.valid();
+   *       // handle JSON payload
+   *     }
+   *   }
+   * });
+   * ```
+   */
+  isFormData(): boolean;
+  /**
+   * Access the request body as a ReadableStream (application/octet-stream).
+   *
+   * @throws Error if the request body is not a ReadableStream
+   */
+  bodyStream(): ReadableStream<Uint8Array>;
+  /**
+   * Check if the request body is a ReadableStream.
+   */
+  isBodyStream(): boolean;
+  /**
+   * Input validation context (only if inputSchema is defined)
+   * @remarks `InputContext`
+   */
+  get input(): ValidatedInputContext<TInputSchema>;
+}
+//#endregion
+//#region ../fragno/dist/http/http-status.d.ts
+//#region src/http/http-status.d.ts
+/**
+ * @module
+ * HTTP Status utility.
+ *
+ * Modified from honojs/hono
+ * Original source: https://github.com/honojs/hono/blob/0e3db674ad3f40be215a55a18062dd8e387ce525/src/utils/http-status.ts
+ * License: MIT
+ * Date obtained: August 28 2025
+ * Copyright (c) 2021-present Yusuke Wada and Hono contributors
+ *
+ */
+type InfoStatusCode = 100 | 101 | 102 | 103;
+type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+type DeprecatedStatusCode = 305 | 306;
+type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
+type ClientErrorStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
+type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+/**
+ * If you want to use an unofficial status, use `UnofficialStatusCode`.
+ */
+type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode;
+type ContentlessStatusCode = 101 | 204 | 205 | 304;
+//#endregion
+//#region ../fragno/dist/api/internal/response-stream.d.ts
+//#region src/api/internal/response-stream.d.ts
+/**
+ * @module
+ * Stream utility.
+ *
+ * Modified from honojs/hono
+ * Original source: https://github.com/honojs/hono/blob/0e3db674ad3f40be215a55a18062dd8e387ce525/src/utils/stream.ts
+ * License: MIT
+ * Date obtained: August 28 2025
+ * Copyright (c) 2021-present Yusuke Wada and Hono contributors
+ */
+type Error$1<Message extends string> = {
+  __errorMessage: Message;
+};
+declare class ResponseStream<TArray> {
+  #private;
+  /**
+   * Whether the stream has been aborted.
+   */
+  get aborted(): boolean;
+  /**
+   * Whether the stream has been closed normally.
+   */
+  get closed(): boolean;
+  /**
+   * The readable stream that the response is piped to.
+   */
+  get responseReadable(): ReadableStream;
+  constructor(writable: WritableStream, readable: ReadableStream);
+  writeRaw(input: Uint8Array | string): Promise<void>;
+  write(input: TArray extends (infer U)[] ? U : Error$1<"To use a streaming response, outputSchema must be an array.">): Promise<void>;
+  sleep(ms: number): Promise<unknown>;
+  close(): Promise<void>;
+  onAbort(listener: () => void | Promise<void>): void;
+  /**
+   * Abort the stream.
+   * You can call this method when stream is aborted by external event.
+   */
+  abort(): Promise<void>;
+}
+//#endregion
+//#region ../fragno/dist/api/request-output-context.d.ts
+//#region src/api/request-output-context.d.ts
+interface ResponseInit<T extends StatusCode = StatusCode> {
+  headers?: HeadersInit;
+  status?: T;
+  statusText?: string;
+}
+type JsonStreamCallbackRunner = (callback: () => void | Promise<void>) => void | Promise<void>;
+type OutputContextOptions = {
+  runJsonStreamCallback?: JsonStreamCallbackRunner;
+};
+declare abstract class OutputContext<const TOutput, const TErrorCode extends string> {
+  #private;
+  constructor(options?: OutputContextOptions);
+  /**
+   * Creates an error response.
+   *
+   * Shortcut for `throw new FragnoApiError(...)`
+   */
+  error: ({ message, code }: {
+    message: string;
+    code: TErrorCode;
+  }, initOrStatus?: ResponseInit | StatusCode, headers?: HeadersInit) => Response;
+  empty: (initOrStatus?: ResponseInit<ContentlessStatusCode> | ContentlessStatusCode, headers?: HeadersInit) => Response;
+  json: (object: TOutput, initOrStatus?: ResponseInit | StatusCode, headers?: HeadersInit) => Response;
+  jsonStream: (cb: (stream: ResponseStream<TOutput>) => void | Promise<void>, { onError, headers }?: {
+    onError?: (error: Error, stream: ResponseStream<TOutput>) => void | Promise<void>;
+    headers?: HeadersInit;
+  }) => Response;
+}
+declare class RequestOutputContext<const TOutputSchema extends StandardSchemaV1 | undefined = undefined, const TErrorCode extends string = string> extends OutputContext<InferOrUnknown<TOutputSchema>, TErrorCode> {
+  #private;
+  constructor(outputSchema?: TOutputSchema, options?: OutputContextOptions);
+}
+//#endregion
+//#region ../fragno/dist/api/shared-types.d.ts
+/**
+ * Configuration for custom fetch behavior in client-side fragments.
+ */
+type FetcherConfig = {
+  type: "options";
+  options: RequestInit;
+} | {
+  type: "function";
+  fetcher: typeof fetch;
+  /**
+   * Use this fetcher even when `window` is undefined.
+   * By default, server-side clients call route handlers directly for SSR.
+   */
+  useOnServer?: boolean;
+};
+/**
+ * Public configuration for Fragno fragments on the client side.
+ */
+interface FragnoPublicClientConfig {
+  mountRoute?: string;
+  baseUrl?: string;
+  fetcherConfig?: FetcherConfig;
+}
+//#endregion
+//#region ../fragno/dist/api/api.d.ts
+//#region src/api/api.d.ts
+type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+type NonGetHTTPMethod = Exclude<HTTPMethod, "GET">;
+interface RequestThisContext {}
+/**
+ * Content types that can be accepted by a route.
+ *
+ * - `"application/json"` (default): JSON request body, validated against inputSchema
+ * - `"multipart/form-data"`: FormData request body (file uploads), no schema validation
+ */
+type RouteContentType = "application/json" | "multipart/form-data" | "application/octet-stream";
+interface FragnoRouteConfig<TMethod extends HTTPMethod, TPath extends string, TInputSchema extends StandardSchemaV1 | undefined, TOutputSchema extends StandardSchemaV1 | undefined, TErrorCode extends string = string, TQueryParameters extends string = string, TThisContext extends RequestThisContext = RequestThisContext> {
+  method: TMethod;
+  path: TPath;
+  /**
+   * The expected content type for this route's request body.
+   *
+   * - `"application/json"` (default): Expects JSON body, will be validated against inputSchema
+   * - `"multipart/form-data"`: Expects FormData body (for file uploads), use `ctx.formData()` in handler
+   *
+   * The server will reject requests with mismatched Content-Type headers.
+   *
+   * @default "application/json"
+   */
+  contentType?: RouteContentType;
+  inputSchema?: TInputSchema;
+  outputSchema?: TOutputSchema;
+  errorCodes?: readonly TErrorCode[];
+  queryParameters?: readonly TQueryParameters[];
+  handler(this: TThisContext, inputCtx: RequestInputContext<TPath, TInputSchema>, outputCtx: RequestOutputContext<TOutputSchema, TErrorCode>): Promise<Response>;
+}
+//#endregion
+//#region ../fragno/dist/client/client-error.d.ts
+//#region src/client/client-error.d.ts
+type FragnoErrorOptions = {
+  cause?: unknown;
+};
+/**
+ * Base error class for all Fragno client errors.
+ */
+declare abstract class FragnoClientError<TCode extends string = string> extends Error {
+  #private;
+  constructor(message: string, code: TCode, options?: FragnoErrorOptions);
+  get code(): TCode | (string & {});
+}
+declare class FragnoClientFetchError extends FragnoClientError<"NO_BODY" | "NETWORK_ERROR" | "ABORT_ERROR"> {
+  constructor(message: string, code: "NO_BODY" | "NETWORK_ERROR" | "ABORT_ERROR", options?: FragnoErrorOptions);
+  static fromUnknownFetchError(error: unknown): FragnoClientFetchError;
+}
+/**
+ * Error thrown when the API result is unexpected, e.g. no json is returned.
+ */
+declare class FragnoClientUnknownApiError extends FragnoClientError<"UNKNOWN_API_ERROR"> {
+  #private;
+  constructor(message: string | undefined, status: StatusCode, options?: FragnoErrorOptions);
+  get status(): StatusCode;
+}
+declare class FragnoClientApiError<TErrorCode extends string = string> extends FragnoClientError<TErrorCode> {
+  #private;
+  constructor({ message, code }: {
+    message: string;
+    code: TErrorCode;
+  }, status: StatusCode, options?: FragnoErrorOptions);
+  get status(): StatusCode;
+  /**
+   * The error code returned by the API.
+   *
+   * The type is `TErrorCode` (the set of known error codes for this route), but may also be a string
+   * for forward compatibility with future error codes.
+   */
+  get code(): TErrorCode | (string & {});
+  static fromResponse<TErrorCode extends string = string>(response: Response): Promise<FragnoClientApiError<TErrorCode> | FragnoClientUnknownApiError>;
+}
+type FragnoClientRequestError<TErrorCode extends string = string> = FragnoClientApiError<TErrorCode> | FragnoClientFetchError | FragnoClientUnknownApiError;
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/atom/index.d.ts
+type AllKeys<T> = T extends any ? keyof T : never;
+type Primitive = boolean | number | string;
+type ReadonlyIfObject<Value> = Value extends undefined ? Value : Value extends ((...args: any) => any) ? Value : Value extends Primitive ? Value : Value extends object ? Readonly<Value> : Value;
+/**
+ * Store object.
+ */
+interface ReadableAtom<Value = any> {
+  /**
+   * Get store value.
+   *
+   * In contrast with {@link ReadableAtom#value} this value will be always
+   * initialized even if store had no listeners.
+   *
+   * ```js
+   * $store.get()
+   * ```
+   *
+   * @returns Store value.
+   */
+  get(): Value;
+  /**
+   * Low-level attribute to read store’s initial value.
+   */
+  readonly init: undefined | Value;
+  /**
+   * Listeners count.
+   */
+  readonly lc: number;
+  /**
+   * Subscribe to store changes.
+   *
+   * In contrast with {@link Store#subscribe} it do not call listener
+   * immediately.
+   *
+   * @param listener Callback with store value and old value.
+   * @returns Function to remove listener.
+   */
+  listen(listener: (value: ReadonlyIfObject<Value>, oldValue: ReadonlyIfObject<Value>) => void): () => void;
+  /**
+   * Low-level method to notify listeners about changes in the store.
+   *
+   * Can cause unexpected behaviour when combined with frontend frameworks
+   * that perform equality checks for values, such as React.
+   */
+  notify(oldValue?: ReadonlyIfObject<Value>): void;
+  /**
+   * Unbind all listeners.
+   */
+  off(): void;
+  /**
+   * Subscribe to store changes and call listener immediately.
+   *
+   * ```
+   * import { $router } from '../store'
+   *
+   * $router.subscribe(page => {
+   *   console.log(page)
+   * })
+   * ```
+   *
+   * @param listener Callback with store value and old value.
+   * @returns Function to remove listener.
+   */
+  subscribe(listener: (value: ReadonlyIfObject<Value>, oldValue?: ReadonlyIfObject<Value>) => void): () => void;
+  /**
+   * Low-level method to read store’s value without calling `onStart`.
+   *
+   * Try to use only {@link ReadableAtom#get}.
+   * Without subscribers, value can be undefined.
+   */
+  readonly value: undefined | Value;
+}
+/**
+ * Store with a way to manually change the value.
+ */
+interface WritableAtom<Value = any> extends ReadableAtom<Value> {
+  /**
+   * Change store value.
+   *
+   * ```js
+   * $router.set({ path: location.pathname, page: parse(location.pathname) })
+   * ```
+   *
+   * @param newValue New store value.
+   */
+  set(newValue: Value): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/map/index.d.ts
+type KeyofBase = keyof any;
+type Get<T, K extends KeyofBase> = Extract<T, { [K1 in K]: any; }>[K];
+type HasIndexSignature<T> = string extends keyof T ? true : false;
+type ValueWithUndefinedForIndexSignatures<Value, Key extends keyof Value> = HasIndexSignature<Value> extends true ? undefined | Value[Key] : Value[Key];
+interface MapStore<Value extends object = any> extends WritableAtom<Value> {
+  /**
+   * Subscribe to store changes.
+   *
+   * In contrast with {@link Store#subscribe} it do not call listener
+   * immediately.
+   *
+   * @param listener Callback with store value and old value.
+   * @param changedKey Key that was changed. Will present only if `setKey`
+   *                   has been used to change a store.
+   * @returns Function to remove listener.
+   */
+  listen(listener: (value: ReadonlyIfObject<Value>, oldValue: ReadonlyIfObject<Value>, changedKey: AllKeys<Value>) => void): () => void;
+  /**
+   * Low-level method to notify listeners about changes in the store.
+   *
+   * Can cause unexpected behaviour when combined with frontend frameworks
+   * that perform equality checks for values, such as React.
+   */
+  notify(oldValue?: ReadonlyIfObject<Value>, changedKey?: AllKeys<Value>): void;
+  /**
+   * Change store value.
+   *
+   * ```js
+   * $settings.set({ theme: 'dark' })
+   * ```
+   *
+   * Operation is atomic, subscribers will be notified once with the new value.
+   * `changedKey` will be undefined
+   *
+   * @param newValue New store value.
+   */
+  set(newValue: Value): void;
+  /**
+   * Change key in store value.
+   *
+   * ```js
+   * $settings.setKey('theme', 'dark')
+   * ```
+   *
+   * To delete key set `undefined`.
+   *
+   * ```js
+   * $settings.setKey('theme', undefined)
+   * ```
+   *
+   * @param key The key name.
+   * @param value New value.
+   */
+  setKey<Key extends AllKeys<Value>>(key: Key, value: Get<Value, Key> | ValueWithUndefinedForIndexSignatures<Value, Key>): void;
+  /**
+   * Subscribe to store changes and call listener immediately.
+   *
+   * ```
+   * import { $router } from '../store'
+   *
+   * $router.subscribe(page => {
+   *   console.log(page)
+   * })
+   * ```
+   *
+   * @param listener Callback with store value and old value.
+   * @param changedKey Key that was changed. Will present only
+   *                   if `setKey` has been used to change a store.
+   * @returns Function to remove listener.
+   */
+  subscribe(listener: (value: ReadonlyIfObject<Value>, oldValue: ReadonlyIfObject<Value> | undefined, changedKey: AllKeys<Value> | undefined) => void): () => void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@nanostores+query@0.3.4_nanostores@1.3.0/node_modules/@nanostores/query/dist/factory.d.ts
+type Key = string;
+type FetcherValue<T = any, E = Error> = {
+  data?: T;
+  error?: E;
+  loading: boolean;
+  promise?: Promise<T>;
+};
+type LazyFetchValue<T = any, E = any> = {
+  data: T;
+} | {
+  error: E;
+};
+type FetcherStore<T = any, E = any> = MapStore<FetcherValue<T, E>> & {
+  _: Symbol;
+  key?: Key;
+  invalidate: (...args: any[]) => void;
+  revalidate: (...args: any[]) => void;
+  mutate: (data?: T) => void;
+  fetch: () => Promise<LazyFetchValue<T, E>>;
+};
+type MutateCb<Data, Result = unknown> = Data extends void ? () => Promise<Result> : (data: Data) => Promise<Result>;
+type MutatorStore<Data = void, Result = unknown, E = Error> = MapStore<{
+  mutate: MutateCb<Data, Result>;
+  data?: Result;
+  loading?: boolean;
+  error?: E;
+}> & {
+  mutate: MutateCb<Data, Result>;
+};
+//#endregion
+//#region ../fragno/dist/client/client.d.ts
+//#region src/client/client.d.ts
+/**
+ * Symbols used to identify hook types
+ */
+declare const GET_HOOK_SYMBOL: unique symbol;
+declare const MUTATOR_HOOK_SYMBOL: unique symbol;
+type FragnoClientHookData<TMethod extends HTTPMethod, TPath extends string, TOutputSchema extends StandardSchemaV1, TErrorCode extends string, TQueryParameters extends string> = {
+  route: FragnoRouteConfig<TMethod, TPath, StandardSchemaV1 | undefined, TOutputSchema, TErrorCode, TQueryParameters>;
+  query(args?: {
+    path?: MaybeExtractPathParamsOrWiden<TPath>;
+    query?: Record<TQueryParameters, string | undefined>;
+  }): Promise<StandardSchemaV1.InferOutput<TOutputSchema>>;
+  store(args?: {
+    path?: MaybeExtractPathParamsOrWiden<TPath, string | ReadableAtom<string>>;
+    query?: Record<TQueryParameters, string | undefined | ReadableAtom<string | undefined>>;
+  }): FetcherStore<StandardSchemaV1.InferOutput<TOutputSchema>, FragnoClientRequestError<TErrorCode>>;
+  [GET_HOOK_SYMBOL]: true;
+} & {
+  readonly _outputSchema?: TOutputSchema;
+};
+type FragnoClientMutatorData<TMethod extends NonGetHTTPMethod, TPath extends string, TInputSchema extends StandardSchemaV1 | undefined, TOutputSchema extends StandardSchemaV1 | undefined, TErrorCode extends string, TQueryParameters extends string> = {
+  route: FragnoRouteConfig<TMethod, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters>;
+  mutateQuery(args?: {
+    body?: InferOr<TInputSchema, undefined>;
+    path?: MaybeExtractPathParamsOrWiden<TPath>;
+    query?: Record<TQueryParameters, string | undefined>;
+  }): Promise<InferOr<TOutputSchema, undefined>>;
+  mutatorStore: MutatorStore<{
+    body?: InferOr<TInputSchema, undefined>;
+    path?: MaybeExtractPathParamsOrWiden<TPath, string | ReadableAtom<string>>;
+    query?: Record<TQueryParameters, string | undefined | ReadableAtom<string | undefined>>;
+  }, InferOr<TOutputSchema, undefined>, FragnoClientRequestError<TErrorCode>>;
+  [MUTATOR_HOOK_SYMBOL]: true;
+} & {
+  readonly _inputSchema?: TInputSchema;
+  readonly _outputSchema?: TOutputSchema;
+};
+//#endregion
+export { FragnoClientRequestError as a, InferOr as c, MaybeExtractPathParamsOrWiden as d, QueryParamsHint as f, ReadableAtom as i, ExtractPathParamsOrWiden as l, FragnoClientMutatorData as n, NonGetHTTPMethod as o, FetcherValue as r, FragnoPublicClientConfig as s, FragnoClientHookData as t, HasPathParams as u };
+//# sourceMappingURL=client-DQE0c7GI.d.ts.map