@nkzw/fate 0.1.1 → 0.1.3

package/lib/types-HECWvGpd.d.mts

@@ -0,0 +1,1193 @@
+import { TRPCClient } from "@trpc/client";
+
+//#region src/mask.d.ts
+type FieldMask = {
+  all: boolean;
+  children: Map<string, FieldMask>;
+};
+//#endregion
+//#region src/selection.d.ts
+/**
+ * Representation of a composed selection including hashed args and the
+ * flat set of field paths to read or fetch.
+ */
+type SelectionPlan = {
+  readonly args: Map<string, Readonly<{
+    hash: string;
+    ignoreKeys?: ReadonlySet<string>;
+    value: AnyRecord;
+  }>>;
+  readonly paths: Set<string>;
+};
+/**
+ * Flattens a view into a `SelectionPlan`, expanding composed views and
+ * partitioning nested args so the client can fetch exactly what is declared.
+ */
+declare const getSelectionPlan: <T extends Entity, S extends Selection<T>, V extends View<T, S>>(viewComposition: V, ref: ViewRef<T["__typename"]> | null) => SelectionPlan;
+//#endregion
+//#region src/cache.d.ts
+declare class ViewDataCache {
+  private cache;
+  private rootDependencies;
+  private dependencyIndex;
+  get<T extends Entity, S extends Selection<T>, V extends View<T, S>>(entityId: EntityId, view: V, ref: ViewRef<T['__typename']>): FateThenable<ViewSnapshot<T, S>> | null;
+  set<T extends Entity, S extends Selection<T>, V extends View<T, S>>(entityId: EntityId, view: V, ref: ViewRef<T['__typename']>, thenable: FateThenable<ViewSnapshot<T, S>>, dependencies: ReadonlySet<EntityId>): void;
+  invalidate(entityId: EntityId): void;
+  private invalidateDependents;
+  private delete;
+}
+//#endregion
+//#region src/store.d.ts
+type List = Readonly<{
+  cursors?: ReadonlyArray<string | undefined>;
+  ids: ReadonlyArray<EntityId>;
+  pagination?: Pagination;
+}>;
+declare class Store {
+  private coverage;
+  private lists;
+  private records;
+  private subscriptions;
+  private listSubscriptions;
+  read(id: EntityId): AnyRecord | undefined;
+  merge(id: EntityId, partial: AnyRecord, paths: Iterable<string>): void;
+  private mergeInternal;
+  deleteRecord(id: EntityId): void;
+  missingForSelection(id: EntityId, paths: Iterable<string>): Set<string>;
+  subscribe(id: EntityId, selection: ReadonlySet<string> | null, fn: () => void): () => void;
+  subscribe(id: EntityId, fn: () => void): () => void;
+  private notify;
+  private notifyListSubscribers;
+  getList(key: string): ReadonlyArray<EntityId> | undefined;
+  getListState(key: string): List | undefined;
+  getListsForField(ownerId: EntityId, field: string): Array<readonly [string, List]>;
+  setList(key: string, state: List): void;
+  restoreList(key: string, list?: List): void;
+  subscribeList(key: string, fn: () => void): () => void;
+  removeReferencesTo(targetId: EntityId, viewDataCache: ViewDataCache, snapshots?: Map<EntityId, Snapshot>, listSnapshots?: Map<string, List>): void;
+  snapshot(id: EntityId): Snapshot;
+  restore(id: EntityId, snapshot: Snapshot): void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@trpc+server@11.8.1_typescript@5.9.3/node_modules/@trpc/server/dist/index.d-D4qZxQJh.d.mts
+//#region src/observable/types.d.ts
+interface Unsubscribable {
+  unsubscribe(): void;
+}
+interface Subscribable<TValue, TError> {
+  subscribe(observer: Partial<Observer<TValue, TError>>): Unsubscribable;
+}
+interface Observable<TValue, TError> extends Subscribable<TValue, TError> {
+  pipe(): Observable<TValue, TError>;
+  pipe<TValue1, TError1>(op1: OperatorFunction<TValue, TError, TValue1, TError1>): Observable<TValue1, TError1>;
+  pipe<TValue1, TError1, TValue2, TError2>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>, op4: OperatorFunction<TValue3, TError3, TValue4, TError4>): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4, TValue5, TError5>(op1: OperatorFunction<TValue, TError, TValue1, TError1>, op2: OperatorFunction<TValue1, TError1, TValue2, TError2>, op3: OperatorFunction<TValue2, TError2, TValue3, TError3>, op4: OperatorFunction<TValue3, TError3, TValue4, TError4>, op5: OperatorFunction<TValue4, TError4, TValue5, TError5>): Observable<TValue2, TError2>;
+}
+interface Observer<TValue, TError> {
+  next: (value: TValue) => void;
+  error: (err: TError) => void;
+  complete: () => void;
+}
+type UnaryFunction<TSource, TReturn> = (source: TSource) => TReturn;
+type OperatorFunction<TValueBefore, TErrorBefore, TValueAfter, TErrorAfter> = UnaryFunction<Subscribable<TValueBefore, TErrorBefore>, Subscribable<TValueAfter, TErrorAfter>>;
+//#endregion
+//#region ../../node_modules/.pnpm/@trpc+server@11.8.1_typescript@5.9.3/node_modules/@trpc/server/dist/unstable-core-do-not-import.d-CjQPvBRI.d.mts
+/**
+ * @public
+ */
+type MaybePromise<TType> = Promise<TType> | TType;
+/**
+ * @internal
+ * Returns the raw input type of a procedure
+ */
+type GetRawInputFn = () => Promise<unknown>;
+type ValueOf<TObj> = TObj[keyof TObj];
+//#endregion
+//#region src/unstable-core-do-not-import/rpc/codes.d.ts
+/**
+ * JSON-RPC 2.0 Error codes
+ *
+ * `-32000` to `-32099` are reserved for implementation-defined server-errors.
+ * For tRPC we're copying the last digits of HTTP 4XX errors.
+ */
+declare const TRPC_ERROR_CODES_BY_KEY: {
+  /**
+   * Invalid JSON was received by the server.
+   * An error occurred on the server while parsing the JSON text.
+   */
+  readonly PARSE_ERROR: -32700;
+  /**
+   * The JSON sent is not a valid Request object.
+   */
+  readonly BAD_REQUEST: -32600;
+  readonly INTERNAL_SERVER_ERROR: -32603;
+  readonly NOT_IMPLEMENTED: -32603;
+  readonly BAD_GATEWAY: -32603;
+  readonly SERVICE_UNAVAILABLE: -32603;
+  readonly GATEWAY_TIMEOUT: -32603;
+  readonly UNAUTHORIZED: -32001;
+  readonly PAYMENT_REQUIRED: -32002;
+  readonly FORBIDDEN: -32003;
+  readonly NOT_FOUND: -32004;
+  readonly METHOD_NOT_SUPPORTED: -32005;
+  readonly TIMEOUT: -32008;
+  readonly CONFLICT: -32009;
+  readonly PRECONDITION_FAILED: -32012;
+  readonly PAYLOAD_TOO_LARGE: -32013;
+  readonly UNSUPPORTED_MEDIA_TYPE: -32015;
+  readonly UNPROCESSABLE_CONTENT: -32022;
+  readonly PRECONDITION_REQUIRED: -32028;
+  readonly TOO_MANY_REQUESTS: -32029;
+  readonly CLIENT_CLOSED_REQUEST: -32099;
+};
+type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
+type TRPC_ERROR_CODE_KEY = keyof typeof TRPC_ERROR_CODES_BY_KEY;
+/**
+ * tRPC error codes that are considered retryable
+ * With out of the box SSE, the client will reconnect when these errors are encountered
+ */
+declare class TRPCError extends Error {
+  readonly cause?: Error;
+  readonly code: "PARSE_ERROR" | "BAD_REQUEST" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_SUPPORTED" | "TIMEOUT" | "CONFLICT" | "PRECONDITION_FAILED" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED_MEDIA_TYPE" | "UNPROCESSABLE_CONTENT" | "PRECONDITION_REQUIRED" | "TOO_MANY_REQUESTS" | "CLIENT_CLOSED_REQUEST";
+  constructor(opts: {
+    message?: string;
+    code: TRPC_ERROR_CODE_KEY;
+    cause?: unknown;
+  });
+} //# sourceMappingURL=TRPCError.d.ts.map
+//#endregion
+//#region src/vendor/standard-schema-v1/spec.d.ts
+/**
+ *
+ * @see https://github.com/standard-schema/standard-schema/blob/main/packages/spec/src/index.ts
+ */
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+} //# sourceMappingURL=spec.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/parser.d.ts
+type ParserZodEsque<TInput, TParsedInput> = {
+  _input: TInput;
+  _output: TParsedInput;
+};
+type ParserValibotEsque<TInput, TParsedInput> = {
+  schema: {
+    _types?: {
+      input: TInput;
+      output: TParsedInput;
+    };
+  };
+};
+type ParserArkTypeEsque<TInput, TParsedInput> = {
+  inferIn: TInput;
+  infer: TParsedInput;
+};
+type ParserStandardSchemaEsque<TInput, TParsedInput> = StandardSchemaV1<TInput, TParsedInput>;
+type ParserMyZodEsque<TInput> = {
+  parse: (input: any) => TInput;
+};
+type ParserSuperstructEsque<TInput> = {
+  create: (input: unknown) => TInput;
+};
+type ParserCustomValidatorEsque<TInput> = (input: unknown) => Promise<TInput> | TInput;
+type ParserYupEsque<TInput> = {
+  validateSync: (input: unknown) => TInput;
+};
+type ParserScaleEsque<TInput> = {
+  assert(value: unknown): asserts value is TInput;
+};
+type ParserWithoutInput<TInput> = ParserCustomValidatorEsque<TInput> | ParserMyZodEsque<TInput> | ParserScaleEsque<TInput> | ParserSuperstructEsque<TInput> | ParserYupEsque<TInput>;
+type ParserWithInputOutput<TInput, TParsedInput> = ParserZodEsque<TInput, TParsedInput> | ParserValibotEsque<TInput, TParsedInput> | ParserArkTypeEsque<TInput, TParsedInput> | ParserStandardSchemaEsque<TInput, TParsedInput>;
+type Parser = ParserWithInputOutput<any, any> | ParserWithoutInput<any>;
+/**
+ * @internal
+ */
+interface ProcedureCallOptions<TContext> {
+  ctx: TContext;
+  getRawInput: GetRawInputFn;
+  input?: unknown;
+  path: string;
+  type: ProcedureType;
+  signal: AbortSignal | undefined;
+} //#endregion
+//#region src/unstable-core-do-not-import/procedure.d.ts
+declare const procedureTypes: readonly ["query", "mutation", "subscription"];
+/**
+ * @public
+ */
+type ProcedureType = (typeof procedureTypes)[number];
+interface BuiltProcedureDef {
+  meta: unknown;
+  input: unknown;
+  output: unknown;
+}
+/**
+ *
+ * @internal
+ */
+interface Procedure<TType extends ProcedureType, TDef extends BuiltProcedureDef> {
+  _def: {
+    /**
+     * These are just types, they can't be used at runtime
+     * @internal
+     */
+    $types: {
+      input: TDef['input'];
+      output: TDef['output'];
+    };
+    procedure: true;
+    type: TType;
+    /**
+     * @internal
+     * Meta is not inferrable on individual procedures, only on the router
+     */
+    meta: unknown;
+    experimental_caller: boolean;
+    /**
+     * The input parsers for the procedure
+     */
+    inputs: Parser[];
+  };
+  meta: TDef['meta'];
+  /**
+   * @internal
+   */
+  (opts: ProcedureCallOptions<unknown>): Promise<TDef['output']>;
+}
+interface QueryProcedure<TDef extends BuiltProcedureDef> extends Procedure<'query', TDef> {}
+interface MutationProcedure<TDef extends BuiltProcedureDef> extends Procedure<'mutation', TDef> {}
+interface SubscriptionProcedure<TDef extends BuiltProcedureDef> extends Procedure<'subscription', TDef> {}
+/**
+ * @deprecated
+ */
+interface LegacyObservableSubscriptionProcedure<TDef extends BuiltProcedureDef> extends SubscriptionProcedure<TDef> {
+  _observable: true;
+}
+type AnyQueryProcedure = QueryProcedure<any>;
+type AnyMutationProcedure = MutationProcedure<any>;
+type AnySubscriptionProcedure = SubscriptionProcedure<any> | LegacyObservableSubscriptionProcedure<any>;
+type AnyProcedure = AnyQueryProcedure | AnyMutationProcedure | AnySubscriptionProcedure;
+type inferProcedureInput<TProcedure extends AnyProcedure> = undefined extends inferProcedureParams<TProcedure>['$types']['input'] ? void | inferProcedureParams<TProcedure>['$types']['input'] : inferProcedureParams<TProcedure>['$types']['input'];
+type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure ? TProcedure['_def'] : never;
+type inferProcedureOutput<TProcedure> = inferProcedureParams<TProcedure>['$types']['output'];
+/**
+ * @internal
+ */
+interface ErrorHandlerOptions<TContext> {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: TContext | undefined;
+} //#endregion
+//#region src/unstable-core-do-not-import/http/types.d.ts
+/**
+ * @deprecated use `Headers` instead, this will be removed in v12
+ */
+//#endregion
+//#region src/unstable-core-do-not-import/rpc/envelopes.d.ts
+/**
+ * Error response
+ */
+interface TRPCErrorShape<TData extends object = object> {
+  code: TRPC_ERROR_CODE_NUMBER;
+  message: string;
+  data: TData;
+}
+/**
+ * JSON-RPC 2.0 Specification
+ */
+//# sourceMappingURL=envelopes.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/transformer.d.ts
+/**
+ * @public
+ */
+interface DataTransformer {
+  serialize(object: any): any;
+  deserialize(object: any): any;
+}
+interface InputDataTransformer extends DataTransformer {
+  /**
+   * This function runs **on the client** before sending the data to the server.
+   */
+  serialize(object: any): any;
+  /**
+   * This function runs **on the server** to transform the data before it is passed to the resolver
+   */
+  deserialize(object: any): any;
+}
+interface OutputDataTransformer extends DataTransformer {
+  /**
+   * This function runs **on the server** before sending the data to the client.
+   */
+  serialize(object: any): any;
+  /**
+   * This function runs **only on the client** to transform the data sent from the server.
+   */
+  deserialize(object: any): any;
+}
+/**
+ * @public
+ */
+interface CombinedDataTransformer {
+  /**
+   * Specify how the data sent from the client to the server should be transformed.
+   */
+  input: InputDataTransformer;
+  /**
+   * Specify how the data sent from the server to the client should be transformed.
+   */
+  output: OutputDataTransformer;
+}
+/**
+ * @public
+ */
+//# sourceMappingURL=parseTRPCMessage.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/error/formatter.d.ts
+/**
+ * @internal
+ */
+type ErrorFormatter<TContext, TShape extends TRPCErrorShape> = (opts: {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: TContext | undefined;
+  shape: DefaultErrorShape;
+}) => TShape;
+/**
+ * @internal
+ */
+type DefaultErrorData = {
+  code: TRPC_ERROR_CODE_KEY;
+  httpStatus: number;
+  /**
+   * Path to the procedure that threw the error
+   */
+  path?: string;
+  /**
+   * Stack trace of the error (only in development)
+   */
+  stack?: string;
+};
+/**
+ * @internal
+ */
+interface DefaultErrorShape extends TRPCErrorShape<DefaultErrorData> {
+  message: string;
+  code: TRPC_ERROR_CODE_NUMBER;
+}
+type Serialize$2 = (value: any) => any;
+type PathArray = readonly (string | number)[];
+type ProducerOnError = (opts: {
+  error: unknown;
+  path: PathArray;
+}) => void;
+interface JSONLProducerOptions {
+  serialize?: Serialize$2;
+  data: Record<string, unknown> | unknown[];
+  onError?: ProducerOnError;
+  formatError?: (opts: {
+    error: unknown;
+    path: PathArray;
+  }) => unknown;
+  maxDepth?: number;
+  /**
+   * Interval in milliseconds to send a ping to the client to keep the connection alive
+   * This will be sent as a whitespace character
+   * @default undefined
+   */
+  pingMs?: number;
+}
+/**
+ * JSON Lines stream producer
+ * @see https://jsonlines.org/
+ */
+//# sourceMappingURL=sse.types.d.ts.map
+//#endregion
+//#region src/unstable-core-do-not-import/stream/sse.d.ts
+type Serialize$1 = (value: any) => any;
+/**
+ * @internal
+ */
+interface SSEPingOptions {
+  /**
+   * Enable ping comments sent from the server
+   * @default false
+   */
+  enabled: boolean;
+  /**
+   * Interval in milliseconds
+   * @default 1000
+   */
+  intervalMs?: number;
+}
+interface SSEClientOptions {
+  /**
+   * Timeout and reconnect after inactivity in milliseconds
+   * @default undefined
+   */
+  reconnectAfterInactivityMs?: number;
+}
+interface SSEStreamProducerOptions<TValue = unknown> {
+  serialize?: Serialize$1;
+  data: AsyncIterable<TValue>;
+  maxDepth?: number;
+  ping?: SSEPingOptions;
+  /**
+   * Maximum duration in milliseconds for the request before ending the stream
+   * @default undefined
+   */
+  maxDurationMs?: number;
+  /**
+   * End the request immediately after data is sent
+   * Only useful for serverless runtimes that do not support streaming responses
+   * @default false
+   */
+  emitAndEndImmediately?: boolean;
+  formatError?: (opts: {
+    error: unknown;
+  }) => unknown;
+  /**
+   * Client-specific options - these will be sent to the client as part of the first message
+   * @default {}
+   */
+  client?: SSEClientOptions;
+}
+/**
+ *
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
+ */
+//#endregion
+//#region src/unstable-core-do-not-import/rootConfig.d.ts
+/**
+ * The initial generics that are used in the init function
+ * @internal
+ */
+interface RootTypes {
+  ctx: object;
+  meta: object;
+  errorShape: DefaultErrorShape;
+  transformer: boolean;
+}
+/**
+ * The default check to see if we're in a server
+ */
+/**
+ * The tRPC root config
+ * @internal
+ */
+interface RootConfig<TTypes extends RootTypes> {
+  /**
+   * The types that are used in the config
+   * @internal
+   */
+  $types: TTypes;
+  /**
+   * Use a data transformer
+   * @see https://trpc.io/docs/v11/data-transformers
+   */
+  transformer: CombinedDataTransformer;
+  /**
+   * Use custom error formatting
+   * @see https://trpc.io/docs/v11/error-formatting
+   */
+  errorFormatter: ErrorFormatter<TTypes['ctx'], TTypes['errorShape']>;
+  /**
+   * Allow `@trpc/server` to run in non-server environments
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default false
+   */
+  allowOutsideOfServer: boolean;
+  /**
+   * Is this a server environment?
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default typeof window === 'undefined' || 'Deno' in window || process.env.NODE_ENV === 'test'
+   */
+  isServer: boolean;
+  /**
+   * Is this development?
+   * Will be used to decide if the API should return stack traces
+   * @default process.env.NODE_ENV !== 'production'
+   */
+  isDev: boolean;
+  defaultMeta?: TTypes['meta'] extends object ? TTypes['meta'] : never;
+  /**
+   * Options for server-sent events (SSE) subscriptions
+   * @see https://trpc.io/docs/client/links/httpSubscriptionLink
+   */
+  sse?: {
+    /**
+     * Enable server-sent events (SSE) subscriptions
+     * @default true
+     */
+    enabled?: boolean;
+  } & Pick<SSEStreamProducerOptions, 'ping' | 'emitAndEndImmediately' | 'maxDurationMs' | 'client'>;
+  /**
+   * Options for batch stream
+   * @see https://trpc.io/docs/client/links/httpBatchStreamLink
+   */
+  jsonl?: Pick<JSONLProducerOptions, 'pingMs'>;
+  experimental?: {};
+}
+/**
+ * @internal
+ */
+type CreateRootTypes<TGenerics extends RootTypes> = TGenerics;
+type AnyRootTypes = CreateRootTypes<{
+  ctx: any;
+  meta: any;
+  errorShape: any;
+  transformer: any;
+}>;
+//#endregion
+//#region src/unstable-core-do-not-import/router.d.ts
+interface RouterRecord {
+  [key: string]: AnyProcedure | RouterRecord;
+}
+type DecorateProcedure<TProcedure extends AnyProcedure> = (input: inferProcedureInput<TProcedure>) => Promise<TProcedure['_def']['type'] extends 'subscription' ? TProcedure extends LegacyObservableSubscriptionProcedure<any> ? Observable<inferProcedureOutput<TProcedure>, TRPCError> : inferProcedureOutput<TProcedure> : inferProcedureOutput<TProcedure>>;
+/**
+ * @internal
+ */
+type DecorateRouterRecord<TRecord extends RouterRecord> = { [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value ? $Value extends AnyProcedure ? DecorateProcedure<$Value> : $Value extends RouterRecord ? DecorateRouterRecord<$Value> : never : never };
+/**
+ * @internal
+ */
+type RouterCallerErrorHandler<TContext> = (opts: ErrorHandlerOptions<TContext>) => void;
+/**
+ * @internal
+ */
+type RouterCaller<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = (
+/**
+ * @note
+ * If passing a function, we recommend it's a cached function
+ * e.g. wrapped in `React.cache` to avoid unnecessary computations
+ */
+
+ctx: TRoot['ctx'] | (() => MaybePromise<TRoot['ctx']>), options?: {
+  onError?: RouterCallerErrorHandler<TRoot['ctx']>;
+  signal?: AbortSignal;
+}) => DecorateRouterRecord<TRecord>;
+type Lazy<TAny> = (() => Promise<TAny>) & {};
+type LazyLoader<TAny> = {
+  load: () => Promise<void>;
+  ref: Lazy<TAny>;
+};
+/**
+ * Lazy load a router
+ * @see https://trpc.io/docs/server/merging-routers#lazy-load
+ */
+/**
+ * @internal
+ */
+interface RouterDef<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
+  _config: RootConfig<TRoot>;
+  router: true;
+  procedure?: never;
+  procedures: TRecord;
+  record: TRecord;
+  lazy: Record<string, LazyLoader<AnyRouter>>;
+}
+interface Router<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
+  _def: RouterDef<TRoot, TRecord>;
+  /**
+   * @see https://trpc.io/docs/v11/server/server-side-calls
+   */
+  createCaller: RouterCaller<TRoot, TRecord>;
+}
+type AnyRouter = Router<any, any>;
+//#endregion
+//#region src/transport.d.ts
+/**
+ * Normalized representation of args passed to a transport.
+ */
+type ResolvedArgsPayload = AnyRecord;
+type TransportMutations = Record<string, MutationShape>;
+type EmptyTransportMutations = Record<never, MutationShape>;
+type Bivariant<Fn extends (...args: Array<any>) => any> = {
+  bivarianceHack: Fn;
+}['bivarianceHack'];
+/**
+ * Contract the fate client expects from a network transport. The transport is
+ * responsible for fetching records by ID, fetching lists, and executing
+ * mutations with the provided selections.
+ */
+interface Transport<Mutations extends TransportMutations = EmptyTransportMutations> {
+  fetchById(type: string, ids: Array<string | number>, select: Iterable<string>, args?: ResolvedArgsPayload): Promise<Array<unknown>>;
+  fetchList?(proc: string, select: Iterable<string>, args?: ResolvedArgsPayload): Promise<{
+    items: Array<{
+      cursor: string | undefined;
+      node: unknown;
+    }>;
+    pagination: Pagination;
+  }>;
+  fetchQuery?(proc: string, select: Iterable<string>, args?: ResolvedArgsPayload): Promise<unknown>;
+  mutate?<K extends Extract<keyof Mutations, string>>(proc: K, input: Mutations[K]['input'], select: Set<string>): Promise<Mutations[K]['output']>;
+}
+/**
+ * Mapping of entity type to tRPC procedures used for fetching entities by ID.
+ */
+type TRPCByIdResolvers<AppRouter extends AnyRouter> = Record<string, (client: TRPCClient<AppRouter>) => (input: {
+  args?: ResolvedArgsPayload;
+  ids: Array<string | number>;
+  select: Array<string>;
+}) => Promise<Array<unknown>>>;
+/**
+ * Mapping of list procedure name to a tRPC resolver factory.
+ */
+type TRPCListResolvers<AppRouter extends AnyRouter> = Record<string, (client: TRPCClient<AppRouter>) => Bivariant<(input: any) => Promise<{
+  items: Array<{
+    cursor: string | undefined;
+    node: unknown;
+  }>;
+  pagination: Pagination;
+}>>>;
+/**
+ * Mapping of query procedure name to a tRPC resolver factory.
+ */
+type TRPCQueryResolvers<AppRouter extends AnyRouter> = Record<string, (client: TRPCClient<AppRouter>) => (input: {
+  args?: ResolvedArgsPayload;
+  select: Array<string>;
+}) => Promise<unknown>>;
+/**
+ * Mapping of a mutation procedure name to a tRPC resolver factory.
+ */
+type MutationResolver<AppRouter extends AnyRouter> = (client: TRPCClient<AppRouter>) => (input: any) => Promise<any>;
+type TRPCMutationResolvers<AppRouter extends AnyRouter> = Record<string, MutationResolver<AppRouter>>;
+type MutationMapFromResolvers<R extends Record<string, MutationResolver<any>>> = { [K in keyof R]: R[K] extends ((client: any) => (input: infer Input) => Promise<infer Output>) ? {
+  input: Input;
+  output: Output;
+} : never };
+type EmptyMutationResolvers<AppRouter extends AnyRouter> = Record<never, MutationResolver<AppRouter>>;
+/**
+ * Builds a `Transport` backed by a tRPC client using the configured resolvers
+ * for by-id queries, lists, and mutations.
+ */
+declare function createTRPCTransport<AppRouter extends AnyRouter, Mutations extends TRPCMutationResolvers<AppRouter> = EmptyMutationResolvers<AppRouter>>({
+  byId,
+  client,
+  lists,
+  mutations,
+  queries
+}: {
+  byId: TRPCByIdResolvers<AppRouter>;
+  client: TRPCClient<AppRouter>;
+  lists?: TRPCListResolvers<AppRouter>;
+  mutations?: Mutations;
+  queries?: TRPCQueryResolvers<AppRouter>;
+}): Transport<MutationMapFromResolvers<Mutations>>;
+//#endregion
+//#region src/client.d.ts
+/**
+ * Strategy used when resolving a request.
+ */
+type RequestMode = /** (default) Use cached data if present, otherwise fetch. */'cache-first' /** Show cached data immediately and refresh in the background. */ | 'stale-while-revalidate' /** Always fetch from the network and ignore cached entries. */ | 'network-only';
+/**
+ * Request options that affect how requests are fetched and retained.
+ */
+type RequestOptions = Readonly<{
+  mode?: RequestMode;
+}>;
+type FateClientOptions<Roots extends FateRoots, Mutations extends FateMutations> = {
+  mutations?: Mutations;
+  roots: Roots;
+  transport: Transport<MutationMapFromDefinitions<Mutations>>;
+  types: ReadonlyArray<Omit<TypeConfig, 'getId'> & Partial<{
+    getId: TypeConfig['getId'];
+  }>>;
+};
+/**
+ * Core client that normalizes records, manages the view cache, and coordinates
+ * data fetching.
+ */
+declare class FateClient<Roots extends FateRoots, Mutations extends FateMutations> {
+  private readonly mutationMap;
+  private readonly parentLists;
+  private readonly rootLists;
+  private readonly pending;
+  private readonly pendingOptimisticMutations;
+  private readonly optimisticMasks;
+  private readonly optimisticByEntity;
+  private readonly optimisticEntityResolutions;
+  private optimisticTokenCounter;
+  private readonly requests;
+  private readonly rootRequests;
+  private readonly stalledRequests;
+  readonly store: Store;
+  private readonly types;
+  private readonly transport;
+  private readonly viewDataCache;
+  readonly actions: MutationActionsFor<Mutations>;
+  readonly mutations: MutationFunctionsFor<Mutations>;
+  readonly roots: Roots;
+  constructor(options: FateClientOptions<Roots, Mutations>);
+  private initializeParentLists;
+  private registerRootList;
+  private insertIntoRootLists;
+  getTypeConfig(type: string): TypeConfig;
+  executeMutation(key: string, input: unknown, select: Set<string>, options?: {
+    args?: AnyRecord;
+    plan?: SelectionPlan;
+  }): Promise<unknown>;
+  write(type: string, data: AnyRecord, select: ReadonlySet<string>, snapshots?: Map<EntityId, Snapshot>, plan?: SelectionPlan, pathPrefix?: string | null, blockedMask?: FieldMask | null, insert?: InsertPosition): string;
+  deleteRecord(type: string, id: string | number, snapshots?: Map<EntityId, Snapshot>, listSnapshots?: Map<string, List>): void;
+  restore(id: EntityId, snapshot: Snapshot): void;
+  restoreList(name: string, list?: List): void;
+  ref<T extends Entity>(type: T['__typename'], id: string | number, view: View<T, Selection<T>>): ViewRef<T['__typename']>;
+  rootListRef(entityId: EntityId, rootView: View<any, any>): Readonly<{
+    __typename: string;
+    id: string | number;
+    [ViewsTag]: Set<string>;
+  }>;
+  readView<T extends Entity, S extends Selection<T>, V extends View<T, S>>(view: V, ref: ViewRef<T['__typename']>): FateThenable<ViewSnapshot<T, S>>;
+  private mergeListState;
+  registerPendingOptimisticMutation(entityId: EntityId, promise: Promise<unknown>): void;
+  resolveOptimisticEntity(optimisticEntityId: EntityId, resolvedEntityId: EntityId): void;
+  registerOptimisticUpdate(entityId: EntityId | null, select: ReadonlySet<string>): number | null;
+  clearOptimisticUpdate(token: number | null): void;
+  getPendingOptimisticMask(entityId: EntityId | null, options?: {
+    excludeToken?: number | null;
+  }): FieldMask | null;
+  private getPendingOptimisticMutations;
+  filterSelectionForPendingOptimistics(entityId: EntityId | null, select: Set<string>, options?: {
+    excludeToken?: number | null;
+  }): Set<string>;
+  loadConnection<V extends View<any, any>>(view: V, connection: ConnectionMetadata, args: Record<string, unknown>, options?: {
+    direction?: 'forward' | 'backward';
+  }): Promise<Readonly<{
+    cursors?: ReadonlyArray<string | undefined>;
+    ids: ReadonlyArray<EntityId>;
+    pagination?: Pagination;
+  }> | undefined>;
+  request<R extends Request$1>(request: R, options?: RequestOptions): Promise<RequestResult<Roots, R>>;
+  releaseRequest(request: Request$1, mode: RequestMode): void;
+  private handleStoreAndNetworkRequest;
+  private getRootType;
+  private executeRequest;
+  private hasRequestData;
+  getRequestResult<R extends Request$1>(request: R): RequestResult<Roots, R>;
+  private fetchByIdAndNormalize;
+  private fetchQueryAndNormalize;
+  private fetchListAndNormalize;
+  private resolveSelection;
+  private writeEntity;
+  private linkParentLists;
+  private readViewSelection;
+  private clearStalledRequestsForEntity;
+  private pendingPrefix;
+  private pendingKey;
+}
+declare function createClient<T extends [FateRoots, FateMutations] = [Record<never, RootDefinition<any, any>>, Record<never, MutationDefinition<any, any, any>>]>(options: FateClientOptions<T[0], T[1]>): FateClient<T[0], T[1]>;
+//#endregion
+//#region src/mutation.d.ts
+/**
+ * Defines a mutation for a given entity type, preserving the input and output
+ * types for transports.
+ */
+declare function mutation<T extends Entity, I, R>(entity: T['__typename']): MutationDefinition<T, I, R>;
+/** Where (or if) to insert the resulting record into relevant lists. */
+type InsertPosition = 'after' | 'before' | 'none';
+/**
+ * Options accepted by a mutation invocation, including optimistic updates and
+ * optional selection for the returned payload.
+ */
+type MutationOptions<Identifier extends MutationIdentifier<any, any, any>> = {
+  /** Optional arguments to pass to the mutation resolver. */args?: Record<string, unknown>; /** If true, deletes the record with the ID specified in the input. */
+  delete?: boolean; /** Input data for the mutation. */
+  input: Omit<MutationInput<Identifier>, 'select'>;
+  insert?: InsertPosition; /** Optional optimistic update to apply immediately. */
+  optimistic?: OptimisticUpdate<MutationResult<Identifier>>; /** Optional view specifying which fields to select from the server. */
+  view?: View<MutationEntity<Identifier>, Selection<MutationEntity<Identifier>>>;
+};
+/**
+ * Callable mutation entry point returned on the client that resolves to either
+ * a successful result or an error.
+ */
+type MutationFunction<I extends MutationIdentifier<any, any, any>> = (options: MutationOptions<I>) => Promise<{
+  error: undefined;
+  result: MutationResult<I>;
+} | {
+  error: Error;
+  result: undefined;
+}>;
+/**
+ * React action-compatible wrapper that can be passed directly to form actions
+ * or transitions.
+ */
+type MutationAction<I extends MutationIdentifier<any, any, any>> = (previousState: unknown,
+/**
+ * Mutation options or 'reset' to reset the action state.
+ */
+
+options: MutationOptions<I> | 'reset') => Promise<{
+  error: undefined;
+  result: MutationResult<I>;
+} | {
+  error: Error;
+  result: undefined;
+}>;
+type MutationIdentifierFor<K extends string, Def extends MutationDefinition<any, any, any>> = Def extends MutationDefinition<infer T, infer I, infer R> ? MutationIdentifier<T, I, R> & Readonly<{
+  key: K;
+}> : never;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type NestedValue<Path extends string, Value> = Path extends `${infer Head}.${infer Tail}` ? { [K in Head]: NestedValue<Tail, Value> } : { [K in Path]: Value };
+/**
+ * Base type for client mutations.
+ */
+type FateMutations = Record<string, MutationDefinition<any, any, any>>;
+type MutationTreeFromRecord<Mutations extends FateMutations, ValueMap extends Record<string, unknown>> = [keyof Mutations] extends [never] ? object : UnionToIntersection<{ [K in keyof Mutations & string]: NestedValue<K, ValueMap[K]> }[keyof Mutations & string]>;
+type MutationFunctionsFor<Mutations extends FateMutations> = MutationTreeFromRecord<Mutations, { [K in keyof Mutations & string]: MutationFunction<MutationIdentifierFor<K, Mutations[K]>> }>;
+type MutationActionsFor<Mutations extends FateMutations> = MutationTreeFromRecord<Mutations, { [K in keyof Mutations & string]: MutationAction<MutationIdentifierFor<K, Mutations[K]>> }>;
+//#endregion
+//#region src/types.d.ts
+/** Canonical runtime name for an entity type as returned by the server. */
+type TypeName = string;
+/** Globally unique identifier for an entity in the normalized cache (`<TypeName>:<id>` format). */
+type EntityId = string;
+/** Internal marker added to objects that represent a view payload. */
+declare const ViewKind: unique symbol;
+/** Symbol used to attach the set of view tags that were spread into a ref or masked record. */
+declare const ViewsTag: unique symbol;
+/** Symbol attached to connection results so pagination helpers can find their metadata. */
+declare const ConnectionTag: unique symbol;
+declare const __FateEntityBrand: unique symbol;
+declare const __FateSelectionBrand: unique symbol;
+declare const __FateMutationEntityBrand: unique symbol;
+declare const __FateMutationInputBrand: unique symbol;
+declare const __FateMutationResultBrand: unique symbol;
+declare const __FateRootResultBrand: unique symbol;
+declare const __FateRootTypeBrand: unique symbol;
+type __ViewEntityAnchor<T extends Entity> = {
+  readonly [__FateEntityBrand]?: T;
+};
+type __ViewSelectionAnchor<S> = {
+  [__FateSelectionBrand]?: S;
+};
+type __MutationEntityAnchor<T extends Entity> = {
+  readonly [__FateMutationEntityBrand]?: T;
+};
+type __MutationInputAnchor<I> = {
+  readonly [__FateMutationInputBrand]?: I;
+};
+type __MutationResultAnchor<R> = {
+  readonly [__FateMutationResultBrand]?: R;
+};
+type __RootResultAnchor<R> = {
+  readonly [__FateRootResultBrand]?: R;
+};
+type __RootTypeAnchor<T extends TypeName> = {
+  readonly [__FateRootTypeBrand]?: T;
+};
+/** Unique key that identifies a view composition entry inside a selection or reference. */
+type ViewTag = `__fate-view__${string}`;
+/** Determines whether a property key is a fate view tag. */
+declare function isViewTag(key: string): key is ViewTag;
+/** Alias for a loose record used throughout the fate's internals. */
+type AnyRecord = Record<string, unknown>;
+type Nullish<T> = Extract<T, null | undefined>;
+type NonNullish<T> = Exclude<T, null | undefined>;
+type WithNullish<T, R> = R | Nullish<T>;
+type SelectionArgs = Readonly<{
+  args: AnyRecord;
+}>;
+/** Metadata stored alongside connection results to power pagination and cache updates. */
+type ConnectionMetadata = Readonly<{
+  args?: AnyRecord;
+  field: string;
+  hash?: string;
+  key: string;
+  owner: EntityId;
+  procedure: string;
+  root?: boolean;
+  type: string;
+}>;
+/** Reference to a normalized entity instance that can be resolved against one or more view tags. */
+type ViewRef<TName extends string> = Readonly<{
+  __typename: TName;
+  id: string | number;
+  [ViewsTag]: Set<string>;
+}>;
+/** Describes how a field relates to another entity for normalization. */
+type RelationDescriptor = /** Field stores a scalar value that does not link to another type. */'scalar' /** Field points to a single entity of the given type. */ | {
+  type: string;
+} /** Field holds a list of entities of the given type. */ | {
+  listOf: string;
+};
+/** Configuration for a server entity type used by the client cache. */
+type TypeConfig = {
+  fields?: Record<string, RelationDescriptor>;
+  getId: (record: unknown) => string | number;
+  type: string;
+};
+/** Pagination state returned alongside connection lists. */
+type Pagination = {
+  hasNext: boolean;
+  hasPrevious: boolean;
+  nextCursor?: string;
+  previousCursor?: string;
+};
+/** Ref for a connection, including pagination metadata. */
+type ConnectionRef<TName extends string> = Readonly<{
+  items: ReadonlyArray<{
+    cursor?: string;
+    node: ViewRef<TName>;
+  }>;
+  pagination?: Pagination;
+}>;
+/** Base shape shared by all entities fetched by fate. */
+type Entity = {
+  __typename: string;
+};
+type PlainObjectSelectionField<V> = V extends Array<infer U> ? PlainObjectSelectionField<U> | true : V extends AnyRecord ? PlainObjectSelection<V> | true : true;
+type PlainObjectSelection<T> = { [K in keyof T]?: PlainObjectSelectionField<T[K]> };
+type ConnectionSelectionBase<T extends Entity> = Readonly<{
+  items: Readonly<{
+    cursor?: true;
+    node: Selection<T> | View<T, Selection<T>>;
+  }>;
+  pagination?: Readonly<{
+    hasNext?: true;
+    hasPrevious?: true;
+    nextCursor?: true;
+    previousCursor?: true;
+  }>;
+}>;
+/** Selection shape for a connection-style list, including pagination metadata and optional arguments. */
+type ConnectionSelection<T extends Entity> = ConnectionSelectionBase<T> | (SelectionArgs & ConnectionSelectionBase<T>);
+type BaseSelectionFieldValue<T extends Entity, K extends keyof T> = NonNullable<T[K]> extends Array<infer U extends Entity> ? true | Selection<U> | ConnectionSelection<U> | View<U, Selection<U>> : NonNullable<T[K]> extends Entity ? true | Selection<NonNullable<T[K]>> | View<NonNullable<T[K]>, Selection<NonNullable<T[K]>>> : NonNullable<T[K]> extends AnyRecord ? PlainObjectSelection<NonNullable<T[K]>> : true;
+type SelectionFieldValue<T extends Entity, K extends keyof T> = BaseSelectionFieldValue<T, K> | SelectionArgs | (SelectionArgs & Extract<BaseSelectionFieldValue<T, K>, object>);
+type SelectionShape<T extends Entity> = { [K in keyof T as K extends '__typename' ? never : K]?: SelectionFieldValue<T, K> } & {
+  __typename?: true;
+};
+type SelectionViewSpread<T extends Entity> = { readonly [K in ViewTag]?: Readonly<{
+  select: Selection<T>;
+  [ViewKind]: true;
+}> };
+/** Declarative selection of the fields a view needs from an entity. */
+type Selection<T extends Entity> = SelectionShape<T> & SelectionViewSpread<T>;
+/** View payload stored on a view tag containing the raw selection used to mask data. */
+type ViewPayload<T extends Entity, S extends Selection<T> = Selection<T>> = Readonly<{
+  select: S;
+  [ViewKind]: true;
+}>;
+/** Definition of a view over an entity type, including the selection of fields. */
+type View<T extends Entity, S extends Selection<T> = Selection<T>> = Readonly<{
+  [viewTag: ViewTag]: ViewPayload<T, S>;
+}> & __ViewEntityAnchor<T> & __ViewSelectionAnchor<S>;
+type HasViewTag<S> = S extends { [K in ViewTag]?: infer P } ? P extends {
+  [ViewKind]: true;
+} ? true : false : false;
+/**
+ * Data returned from a resolved view with masking applied and view tags
+ * attached for downstream composition.
+ */
+type ViewData<T extends Entity, S extends Selection<T>> = Readonly<(S extends Selection<T> ? Mask<T, S> : T) & {
+  [ViewsTag]: Set<string>;
+}>;
+/**
+ * Snapshot returned by the cache for a view, including the masked data and all
+ * referenced entity IDs.
+ */
+type ViewSnapshot<T extends Entity, S extends Selection<T>> = Readonly<{
+  coverage: ReadonlyArray<readonly [id: EntityId, paths: ReadonlySet<string>]>;
+  data: ViewData<T, S>;
+}>;
+type ConnectionMask<T extends Entity, S> = S extends {
+  items: infer ItemSelection;
+  pagination?: infer PaginationSelection;
+} ? {
+  items: ItemSelection extends {
+    cursor?: infer CursorSelection;
+    node: unknown;
+  } ? Array<(CursorSelection extends true ? {
+    cursor: string;
+  } : Record<string, never>) & {
+    node: ViewRef<T['__typename']>;
+  }> : Array<{
+    node: ViewRef<T['__typename']>;
+  }>;
+} & (PaginationSelection extends object ? {
+  pagination: { [K in keyof PaginationSelection]: Pagination[K & keyof Pagination] };
+} : Record<string, never>) : Array<T>;
+type EntityName<T> = T extends {
+  __typename: infer N extends string;
+} ? N : never;
+/** Recursively applies a view selection to an entity to mask fields that aren't selected. */
+type MaskNonNullish<T, S> = T extends Array<infer U extends Entity> ? S extends true ? Array<U> : S extends ConnectionSelection<U> ? ConnectionMask<U, S> : HasViewTag<S> extends true ? Array<ViewRef<U['__typename']>> : Array<Mask<U, S>> : S extends true ? T : S extends object ? HasViewTag<S> extends true ? NonNullish<T> extends Entity ? ViewRef<EntityName<NonNullish<T>>> : ViewRef<EntityName<NonNullable<T>>> : { [K in keyof S as K extends 'args' ? never : K]: S[K] extends true ? NonNullish<T>[Extract<K, keyof T>] : Mask<NonNullish<T>[Extract<K, keyof T>], Extract<S[K], object>> } & (T extends Entity ? Pick<NonNullish<T>, '__typename'> : Record<never, never>) : T;
+type Mask<T, S> = WithNullish<T, MaskNonNullish<NonNullish<T>, S>>;
+/** Entity type captured from a view definition. */
+type ViewEntity<V> = V extends View<infer T, any> ? T : never;
+/** Name of the entity type captured from a view definition. */
+type ViewEntityName<V> = ViewEntity<V>['__typename'] & string;
+/** Selection captured from a view definition. */
+type ViewSelection<V> = V extends {
+  readonly [__FateSelectionBrand]?: infer S;
+} ? S : never;
+/** Definition of a list request for fetching data from the backend. */
+type ListItem<V extends View<any, any>> = Readonly<{
+  args?: Record<string, unknown>;
+  list: V;
+}>;
+/** Definition of a root-level query request. */
+type QueryItem<V extends View<any, any>> = Readonly<{
+  args?: Record<string, unknown>;
+  view: V;
+}>;
+/** Definition of a node request with one explicit ID for fetching data from the backend. */
+type NodeItem<V extends View<any, any>> = Readonly<{
+  id: string | number;
+  view: V;
+}>;
+/** Definition of a node request with explicit IDs for fetching data from the backend. */
+type NodesItem<V extends View<any, any>> = Readonly<{
+  ids: ReadonlyArray<string | number>;
+  view: V;
+}>;
+type RequestItem = ListItem<View<any, any>> | NodeItem<View<any, any>> | NodesItem<View<any, any>> | QueryItem<View<any, any>>;
+/** Collection of node and list requests describing the data a screen needs. */
+type Request$1 = Record<string, RequestItem>;
+type AnyView = View<any, any>;
+type AnyListItem = ListItem<AnyView>;
+type AnyQueryItem = QueryItem<AnyView>;
+type AnyNodeItem = NodeItem<AnyView>;
+type AnyNodesItem = NodesItem<AnyView>;
+type AnyRequestItem = AnyListItem | AnyNodeItem | AnyNodesItem | AnyQueryItem;
+type AnyRequest = Record<string, AnyRequestItem>;
+/**
+ * Typed result returned by `useRequest` and `FateClient.request`, mapping each
+ * request key to an array of view refs for the requested type.
+ */
+type ConnectionNodeType<Root> = Root extends {
+  items?: {
+    node?: infer Node;
+  };
+} ? ViewEntityName<Node & View<any, any>> : never;
+type ListResult<Item extends AnyRequestItem, Type extends TypeName, Result> = Item extends AnyNodeItem ? ViewRef<Type> : Item extends AnyNodesItem ? Array<ViewRef<Type>> : Item extends AnyQueryItem ? Result extends null ? ViewRef<Type> | null : ViewRef<Type> : Item extends AnyListItem ? Item['list'] extends {
+  items?: {
+    node?: View<any, any>;
+  };
+} ? Readonly<{
+  items: ReadonlyArray<{
+    cursor?: string | undefined;
+    node: ViewRef<ConnectionNodeType<Item['list']>>;
+  }>;
+  pagination?: Pagination;
+}> : Array<ViewRef<Type>> : never;
+/**
+ * The result of a `FateClient.request` and `useRequest` call, mapping each
+ * request key to its corresponding result.
+ */
+type RequestResult<R extends FateRoots, Q extends AnyRequest> = { [K in keyof Q]: K extends keyof R ? ListResult<Q[K], RootType<R[K]>, RootResult<R[K]>> : never };
+/** Brand used on root definitions to mark their identity in the d.ts output. */
+declare const RootKind = "__fate__root";
+/** Brand used on mutation definitions to mark their identity in the d.ts output. */
+declare const MutationKind = "__fate__mutation";
+/** Metadata describing a root query for a particular entity and result shape. */
+type RootDefinition<Type extends TypeName, Result> = Readonly<{
+  [RootKind]: true;
+  type: Type;
+}> & __RootResultAnchor<Result> & __RootTypeAnchor<Type>;
+/** Minimal root description used for typing root maps. */
+type FateRoots = Record<string, RootDefinition<TypeName, unknown>>;
+/** Extracts the entity type name from a root definition. */
+type RootType<R> = R extends __RootTypeAnchor<infer T> ? T : never;
+/** Extracts the result type from a root definition. */
+type RootResult<R> = R extends __RootResultAnchor<infer Data> ? Data : never;
+/** Metadata describing a mutation for a particular entity, input, and output. */
+type MutationDefinition<T extends Entity, I, R> = Readonly<{
+  entity: T['__typename'];
+  [MutationKind]: true;
+}> & __MutationEntityAnchor<T> & __MutationInputAnchor<I> & __MutationResultAnchor<R>;
+type MutationIdentifier<T extends Entity, I, R> = MutationDefinition<T, I, R> & Readonly<{
+  key: string;
+}>;
+/** Extracts the input type from a mutation definition or identifier. */
+type MutationInput<M> = M extends __MutationInputAnchor<infer I> ? I : never;
+/** Extracts the result type from a mutation definition or identifier. */
+type MutationResult<M> = M extends __MutationResultAnchor<infer R> ? R : never;
+/** Extracts the entity type from a mutation definition or identifier. */
+type MutationEntity<M> = M extends __MutationEntityAnchor<infer E> ? E : never;
+/** Minimal mutation description used for transport typing. */
+type MutationShape = {
+  input: unknown;
+  output: unknown;
+};
+/**
+ * Convenience helper that maps mutation definitions to their input/output
+ * shapes for use by transports.
+ */
+type MutationMapFromDefinitions<D extends FateMutations> = { [K in keyof D]: {
+  input: MutationInput<D[K]>;
+  output: MutationResult<D[K]>;
+} };
+type OptimisticUpdateValue<T> = T extends ReadonlyArray<infer U> ? Array<OptimisticUpdateValue<U>> : NonNullish<T> extends AnyRecord ? OptimisticUpdate<NonNullish<T>> | Nullish<T> : NonNullish<T> | Nullish<T>;
+/** Shape used to describe optimistic updates for mutations. */
+type OptimisticUpdate<T> = { [K in keyof T]?: OptimisticUpdateValue<T[K]> };
+/** Snapshot captured before mutating the cache, used to roll back on errors. */
+type Snapshot = Readonly<{
+  mask?: FieldMask;
+  record?: AnyRecord;
+}>;
+/** Promise-like value returned by cache reads that already have a resolved payload for React `use`. */
+interface FateThenable<T> extends PromiseLike<T> {
+  status: 'fulfilled';
+  value: T;
+}
+//#endregion
+export { ViewSelection as A, RequestOptions as B, TypeConfig as C, ViewEntity as D, ViewData as E, isViewTag as F, getSelectionPlan as G, Transport as H, FateMutations as I, mutation as L, ViewTag as M, __FateEntityBrand as N, ViewEntityName as O, __FateSelectionBrand as P, FateClient as R, Snapshot as S, View as T, createTRPCTransport as U, createClient as V, QueryProcedure as W, Pagination as _, Entity as a, RootDefinition as b, FateThenable as c, MutationDefinition as d, MutationEntity as f, NodesItem as g, MutationResult as h, ConnectionTag as i, ViewSnapshot as j, ViewRef as k, ListItem as l, MutationInput as m, ConnectionMetadata as n, EntityId as o, MutationIdentifier as p, ConnectionRef as r, FateRoots as s, AnyRecord as t, Mask as u, Request$1 as v, TypeName as w, Selection as x, RequestResult as y, RequestMode as z };