@nkzw/fate 0.0.1

package/lib/index.d.mts

@@ -0,0 +1,585 @@
+import { TRPCClient } from "@trpc/client";
+import { AnyRouter } from "@trpc/server";
+
+//#region src/mask.d.ts
+type FieldMask = {
+  all: boolean;
+  children: Map<string, FieldMask>;
+};
+//#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;
+type __ViewEntityAnchor<T$1 extends Entity> = {
+  readonly [__FateEntityBrand]?: T$1;
+};
+type __ViewSelectionAnchor<S$1> = {
+  [__FateSelectionBrand]?: S$1;
+};
+type __MutationEntityAnchor<T$1 extends Entity> = {
+  readonly [__FateMutationEntityBrand]?: T$1;
+};
+type __MutationInputAnchor<I$1> = {
+  readonly [__FateMutationInputBrand]?: I$1;
+};
+type __MutationResultAnchor<R$1> = {
+  readonly [__FateMutationResultBrand]?: R$1;
+};
+/** 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 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$1> = { [K in keyof T$1]?: PlainObjectSelectionField<T$1[K]> };
+type ConnectionSelectionBase<T$1 extends Entity> = Readonly<{
+  items: Readonly<{
+    cursor?: true;
+    node: Selection<T$1> | View<T$1, Selection<T$1>>;
+  }>;
+  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$1 extends Entity> = ConnectionSelectionBase<T$1> | (SelectionArgs & ConnectionSelectionBase<T$1>);
+type BaseSelectionFieldValue<T$1 extends Entity, K$1 extends keyof T$1> = NonNullable<T$1[K$1]> extends Array<infer U extends Entity> ? true | Selection<U> | ConnectionSelection<U> | View<U, Selection<U>> : NonNullable<T$1[K$1]> extends Entity ? true | Selection<NonNullable<T$1[K$1]>> | View<NonNullable<T$1[K$1]>, Selection<NonNullable<T$1[K$1]>>> : NonNullable<T$1[K$1]> extends AnyRecord ? PlainObjectSelection<NonNullable<T$1[K$1]>> : true;
+type SelectionFieldValue<T$1 extends Entity, K$1 extends keyof T$1> = BaseSelectionFieldValue<T$1, K$1> | SelectionArgs | (SelectionArgs & Extract<BaseSelectionFieldValue<T$1, K$1>, object>);
+type SelectionShape<T$1 extends Entity> = { [K in keyof T$1 as K extends '__typename' ? never : K]?: SelectionFieldValue<T$1, K> } & {
+  __typename?: true;
+};
+type SelectionViewSpread<T$1 extends Entity> = { readonly [K in ViewTag]?: Readonly<{
+  select: Selection<T$1>;
+  [ViewKind]: true;
+}> };
+/** Declarative selection of the fields a view needs from an entity. */
+type Selection<T$1 extends Entity> = SelectionShape<T$1> & SelectionViewSpread<T$1>;
+/** View payload stored on a view tag containing the raw selection used to mask data. */
+type ViewPayload<T$1 extends Entity, S$1 extends Selection<T$1> = Selection<T$1>> = Readonly<{
+  select: S$1;
+  [ViewKind]: true;
+}>;
+/** Definition of a view over an entity type, including the selection of fields. */
+type View<T$1 extends Entity, S$1 extends Selection<T$1> = Selection<T$1>> = Readonly<{
+  [viewTag: ViewTag]: ViewPayload<T$1, S$1>;
+}> & __ViewEntityAnchor<T$1> & __ViewSelectionAnchor<S$1>;
+type HasViewTag<S$1> = S$1 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$1 extends Entity, S$1 extends Selection<T$1>> = Readonly<(S$1 extends Selection<T$1> ? Mask<T$1, S$1> : T$1) & {
+  [ViewsTag]: Set<string>;
+}>;
+/**
+ * Snapshot returned by the cache for a view, including the masked data and all
+ * referenced entity IDs.
+ */
+type ViewSnapshot<T$1 extends Entity, S$1 extends Selection<T$1>> = Readonly<{
+  coverage: ReadonlyArray<readonly [id: EntityId, paths: ReadonlySet<string>]>;
+  data: ViewData<T$1, S$1>;
+}>;
+type ConnectionMask<T$1 extends Entity, S$1> = S$1 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$1['__typename']>;
+  }> : Array<{
+    node: ViewRef<T$1['__typename']>;
+  }>;
+} & (PaginationSelection extends object ? {
+  pagination: { [K in keyof PaginationSelection]: Pagination[K & keyof Pagination] };
+} : Record<string, never>) : Array<T$1>;
+type EntityName<T$1> = T$1 extends {
+  __typename: infer N extends string;
+} ? N : never;
+/** Recursively applies a view selection to an entity to mask fields that aren't selected. */
+type Mask<T$1, S$1> = T$1 extends Array<infer U extends Entity> ? S$1 extends true ? Array<U> : S$1 extends ConnectionSelection<U> ? ConnectionMask<U, S$1> : HasViewTag<S$1> extends true ? Array<ViewRef<U['__typename']>> : Array<Mask<U, S$1>> : S$1 extends true ? T$1 : S$1 extends object ? HasViewTag<S$1> extends true ? ViewRef<EntityName<NonNullable<T$1>>> : { [K in keyof S$1 as K extends 'args' ? never : K]: S$1[K] extends true ? NonNullable<T$1>[Extract<K, keyof T$1>] : Mask<NonNullable<T$1>[Extract<K, keyof T$1>], Extract<S$1[K], object>> } & (T$1 extends Entity ? Pick<NonNullable<T$1>, '__typename'> : Record<never, never>) : T$1;
+/** 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>;
+  root: V;
+  type: ViewEntityName<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;
+  root: V;
+  type: ViewEntityName<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>;
+  root: V;
+  type: ViewEntityName<V>;
+}>;
+type RequestItem = ListItem<View<any, any>> | NodeItem<View<any, any>> | NodesItem<View<any, any>>;
+/** Collection of node and list requests describing the data a screen needs. */
+type Request = Record<string, RequestItem>;
+type AnyView = View<any, any>;
+type AnyListItem = ListItem<AnyView>;
+type AnyNodeItem = NodeItem<AnyView>;
+type AnyNodesItem = NodesItem<AnyView>;
+type AnyRequestItem = AnyListItem | AnyNodeItem | AnyNodesItem;
+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> = Item extends AnyNodeItem ? ViewRef<Item['type']> : Item extends AnyNodesItem ? Array<ViewRef<Item['type']>> : Item extends AnyListItem ? Item['root'] extends {
+  items?: {
+    node?: View<any, any>;
+  };
+} ? Readonly<{
+  items: ReadonlyArray<{
+    cursor?: string | undefined;
+    node: ViewRef<ConnectionNodeType<Item['root']>>;
+  }>;
+  pagination?: Pagination;
+}> : Array<ViewRef<Item['type']>> : never;
+/**
+ * The result of a `FateClient.request` and `useRequest` call, mapping each
+ * request key to its corresponding result.
+ */
+type RequestResult<Q extends AnyRequest> = { [K in keyof Q]: ListResult<Q[K]> };
+/** Brand used on mutation definitions to mark their identity in the d.ts output. */
+declare const MutationKind = "__fate__mutation";
+/** Metadata describing a mutation for a particular entity, input, and output. */
+type MutationDefinition<T$1 extends Entity, I$1, R$1> = Readonly<{
+  entity: T$1['__typename'];
+  [MutationKind]: true;
+}> & __MutationEntityAnchor<T$1> & __MutationInputAnchor<I$1> & __MutationResultAnchor<R$1>;
+type MutationIdentifier<T$1 extends Entity, I$1, R$1> = MutationDefinition<T$1, I$1, R$1> & 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 Record<string, MutationDefinition<any, any, any>>> = { [K in keyof D]: {
+  input: MutationInput<D[K]>;
+  output: MutationResult<D[K]>;
+} };
+type Nullish<T$1> = Extract<T$1, null | undefined>;
+type NonNullish<T$1> = Exclude<T$1, null | undefined>;
+type OptimisticUpdateValue<T$1> = T$1 extends ReadonlyArray<infer U> ? Array<OptimisticUpdateValue<U>> : NonNullish<T$1> extends AnyRecord ? OptimisticUpdate<NonNullish<T$1>> | Nullish<T$1> : NonNullish<T$1> | Nullish<T$1>;
+/** Shape used to describe optimistic updates for mutations. */
+type OptimisticUpdate<T$1> = { [K in keyof T$1]?: OptimisticUpdateValue<T$1[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$1> extends PromiseLike<T$1> {
+  status: 'fulfilled';
+  value: 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$1 extends Entity, I$1, R$1>(entity: T$1['__typename']): MutationDefinition<T$1, I$1, R$1>;
+/**
+ * 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'>;
+  /** 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$1 extends MutationIdentifier<any, any, any>> = (options: MutationOptions<I$1>) => Promise<{
+  error: undefined;
+  result: MutationResult<I$1>;
+} | {
+  error: Error;
+  result: undefined;
+}>;
+/**
+ * React action-compatible wrapper that can be passed directly to form actions
+ * or transitions.
+ */
+type MutationAction<I$1 extends MutationIdentifier<any, any, any>> = (previousState: unknown,
+/**
+ * Mutation options or 'reset' to reset the action state.
+ */
+options: MutationOptions<I$1> | 'reset') => Promise<{
+  error: undefined;
+  result: MutationResult<I$1>;
+} | {
+  error: Error;
+  result: undefined;
+}>;
+//#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$1 extends Entity, S$1 extends Selection<T$1>, V extends View<T$1, S$1>>(viewComposition: V, ref: ViewRef<T$1["__typename"]> | null) => SelectionPlan;
+//#endregion
+//#region src/cache.d.ts
+declare class ViewDataCache {
+  private cache;
+  private rootDependencies;
+  private dependencyIndex;
+  get<T$1 extends Entity, S$1 extends Selection<T$1>, V extends View<T$1, S$1>>(entityId: EntityId, view: V, ref: ViewRef<T$1['__typename']>): FateThenable<ViewSnapshot<T$1, S$1>> | null;
+  set<T$1 extends Entity, S$1 extends Selection<T$1>, V extends View<T$1, S$1>>(entityId: EntityId, view: V, ref: ViewRef<T$1['__typename']>, thenable: FateThenable<ViewSnapshot<T$1, S$1>>, 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 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>;
+/**
+ * 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;
+  }>;
+  mutate?<K$1 extends Extract<keyof Mutations, string>>(proc: K$1, input: Mutations[K$1]['input'], select: Set<string>): Promise<Mutations[K$1]['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>) => (input: {
+  args?: ResolvedArgsPayload;
+  select: Array<string>;
+}) => Promise<{
+  items: Array<{
+    cursor: string | undefined;
+    node: unknown;
+  }>;
+  pagination: Pagination;
+}>>;
+/**
+ * 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$1 extends Record<string, MutationResolver<any>>> = { [K in keyof R$1]: R$1[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
+}: {
+  byId: TRPCByIdResolvers<AppRouter>;
+  client: TRPCClient<AppRouter>;
+  lists?: TRPCListResolvers<AppRouter>;
+  mutations?: Mutations;
+}): 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 MutationIdentifierFor<K$1 extends string, Def extends MutationDefinition<any, any, any>> = Def extends MutationDefinition<infer T, infer I, infer R> ? MutationIdentifier<T, I, R> & Readonly<{
+  key: K$1;
+}> : never;
+type MutationTransport<Mutations extends Record<string, MutationDefinition<any, any, any>>> = MutationMapFromDefinitions<Mutations>;
+type UnionToIntersection<U$1> = (U$1 extends any ? (k: U$1) => 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 };
+type MutationTreeFromRecord<Mutations extends Record<string, MutationDefinition<any, any, any>>, 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 Record<string, MutationDefinition<any, any, any>>> = MutationTreeFromRecord<Mutations, { [K in keyof Mutations & string]: MutationFunction<MutationIdentifierFor<K, Mutations[K]>> }>;
+type MutationActionsFor<Mutations extends Record<string, MutationDefinition<any, any, any>>> = MutationTreeFromRecord<Mutations, { [K in keyof Mutations & string]: MutationAction<MutationIdentifierFor<K, Mutations[K]>> }>;
+type EmptyMutations = Record<never, MutationDefinition<any, any, any>>;
+type FateClientOptions<Mutations extends Record<string, MutationDefinition<any, any, any>> = EmptyMutations> = {
+  mutations?: Mutations;
+  transport: Transport<MutationTransport<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<Mutations extends Record<string, MutationDefinition<any, any, any>> = EmptyMutations> {
+  private readonly mutationMap;
+  private readonly parentLists;
+  private readonly pending;
+  private readonly optimisticMasks;
+  private readonly optimisticByEntity;
+  private optimisticTokenCounter;
+  private readonly requests;
+  private readonly stalledRequests;
+  readonly store: Store;
+  private readonly types;
+  private readonly transport;
+  private readonly viewDataCache;
+  readonly mutations: MutationFunctionsFor<Mutations>;
+  readonly actions: MutationActionsFor<Mutations>;
+  constructor(options: FateClientOptions<Mutations>);
+  private initializeParentLists;
+  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): 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$1 extends Entity>(type: T$1['__typename'], id: string | number, view: View<T$1, Selection<T$1>>): ViewRef<T$1['__typename']>;
+  rootListRef(entityId: EntityId, rootView: View<any, any>): Readonly<{
+    __typename: string;
+    id: string | number;
+    [ViewsTag]: Set<string>;
+  }>;
+  readView<T$1 extends Entity, S$1 extends Selection<T$1>, V extends View<T$1, S$1>>(view: V, ref: ViewRef<T$1['__typename']>): FateThenable<ViewSnapshot<T$1, S$1>>;
+  private mergeListState;
+  registerOptimisticUpdate(entityId: EntityId | null, select: ReadonlySet<string>): number | null;
+  clearOptimisticUpdate(token: number | null): void;
+  getPendingOptimisticMask(entityId: EntityId | null, options?: {
+    excludeToken?: number | null;
+  }): FieldMask | null;
+  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$1 extends Request>(request: R$1, options?: RequestOptions): Promise<RequestResult<R$1>>;
+  releaseRequest(request: Request, mode: RequestMode): void;
+  private handleStoreAndNetworkRequest;
+  private executeRequest;
+  private hasRequestData;
+  getRequestResult<R$1 extends Request>(request: R$1): RequestResult<R$1>;
+  private fetchByIdAndNormalize;
+  private fetchListAndNormalize;
+  private resolveListSelection;
+  private writeEntity;
+  private linkParentLists;
+  private readViewSelection;
+  private clearStalledRequestsForEntity;
+  private pendingPrefix;
+  private pendingKey;
+}
+declare function createClient<Mutations extends Record<string, MutationDefinition<any, any, any>> = EmptyMutations>(options: FateClientOptions<Mutations>): FateClient<Mutations>;
+//#endregion
+//#region src/ref.d.ts
+/**
+ * Builds the canonical cache ID for an entity.
+ */
+declare const toEntityId: (type: TypeName, rawId: string | number) => EntityId;
+//#endregion
+//#region src/view.d.ts
+type SelectionValidation<T$1 extends Entity, S$1 extends Selection<T$1>> = Exclude<keyof Omit<S$1, typeof __FateEntityBrand | typeof __FateSelectionBrand>, keyof Selection<T$1>> extends never ? unknown : never;
+/**
+ * Creates a reusable view for an object using the declared selection.
+ *
+ * @example
+ * const PostView = view<Post>()({
+ *   id: true,
+ *   title: true,
+ * });
+ */
+declare function view<T$1 extends Entity>(): <S$1 extends Selection<T$1>>(select: S$1 & SelectionValidation<T$1, S$1>) => View<T$1, S$1>;
+//#endregion
+export { type ConnectionMetadata, type ConnectionRef, ConnectionTag, type Entity, type EntityId, FateClient, type AnyRecord as FateRecord, type ListItem, type Mask, type MutationDefinition, type MutationEntity, type MutationIdentifier, type MutationInput, type MutationResult, type NodesItem, type Pagination, type Request, type RequestMode, type RequestOptions, type RequestResult, type Selection, type Snapshot, type Transport, type TypeConfig, type View, type ViewData, type ViewEntity, type ViewEntityName, type ViewRef, type ViewSelection, type ViewSnapshot, type ViewTag, createClient, createTRPCTransport, getSelectionPlan, isViewTag, mutation, toEntityId, view };