@nkzw/fate 0.1.3 → 1.0.0

package/lib/{types-HECWvGpd.d.mts → types-Dz46PXr3.d.mts}

@@ -17,6 +17,7 @@ type SelectionPlan = {
     ignoreKeys?: ReadonlySet<string>;
     value: AnyRecord;
   }>>;
+  readonly live: Map<string, ConnectionLivePolicy>;
   readonly paths: Set<string>;
 };
 /**
@@ -25,51 +26,7 @@ type SelectionPlan = {
  */
 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 ../../node_modules/.pnpm/@trpc+server@11.17.0_typescript@5.9.3/node_modules/@trpc/server/dist/index.d-D4qZxQJh.d.mts
 //#region src/observable/types.d.ts
 interface Unsubscribable {
   unsubscribe(): void;
@@ -93,7 +50,7 @@ interface Observer<TValue, TError> {
 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
+//#region ../../node_modules/.pnpm/@trpc+server@11.17.0_typescript@5.9.3/node_modules/@trpc/server/dist/unstable-core-do-not-import.d-BdVSvUCr.d.mts
 /**
  * @public
  */
@@ -263,6 +220,10 @@ interface ProcedureCallOptions<TContext> {
   path: string;
   type: ProcedureType;
   signal: AbortSignal | undefined;
+  /**
+   * The index of this call in a batch request.
+   */
+  batchIndex: number;
 } //#endregion
 //#region src/unstable-core-do-not-import/procedure.d.ts
 declare const procedureTypes: readonly ["query", "mutation", "subscription"];
@@ -619,7 +580,6 @@ type RouterCaller<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = (
  * 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;
@@ -663,6 +623,37 @@ type EmptyTransportMutations = Record<never, MutationShape>;
 type Bivariant<Fn extends (...args: Array<any>) => any> = {
   bivarianceHack: Fn;
 }['bivarianceHack'];
+type TRPCListResult = {
+  items: Array<{
+    cursor?: string;
+    node?: unknown;
+  }>;
+  pagination: Pagination;
+};
+type LiveEventHandlers = Readonly<{
+  onData: (record: unknown, select?: ReadonlyArray<string>) => void;
+  onDelete?: (id?: string | number) => void;
+  onError?: (error: unknown) => void;
+}>;
+type LiveConnectionEvent = Readonly<{
+  edge: {
+    cursor?: string;
+    node: unknown;
+  };
+  nodeType: string;
+  targetCursor?: string;
+  type: 'appendEdge' | 'appendNode' | 'insertEdgeAfter' | 'insertEdgeBefore' | 'prependEdge' | 'prependNode';
+}> | Readonly<{
+  id: string | number;
+  nodeType: string;
+  type: 'deleteEdge';
+}> | Readonly<{
+  type: 'invalidate';
+}>;
+type LiveConnectionEventHandlers = Readonly<{
+  onError?: (error: unknown) => void;
+  onEvent: (event: LiveConnectionEvent) => void;
+}>;
 /**
  * Contract the fate client expects from a network transport. The transport is
  * responsible for fetching records by ID, fetching lists, and executing
@@ -679,6 +670,8 @@ interface Transport<Mutations extends TransportMutations = EmptyTransportMutatio
   }>;
   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']>;
+  subscribeById?(type: string, id: string | number, select: Iterable<string>, args: ResolvedArgsPayload | undefined, handlers: LiveEventHandlers): () => void;
+  subscribeConnection?(procedure: string, type: string, args: ResolvedArgsPayload | undefined, select: Iterable<string>, selectionArgs: ResolvedArgsPayload | undefined, handlers: LiveConnectionEventHandlers): () => void;
 }
 /**
  * Mapping of entity type to tRPC procedures used for fetching entities by ID.
@@ -687,17 +680,11 @@ type TRPCByIdResolvers<AppRouter extends AnyRouter> = Record<string, (client: TR
   args?: ResolvedArgsPayload;
   ids: Array<string | number>;
   select: Array<string>;
-}) => Promise<Array<unknown>>>;
+}) => Promise<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;
-}>>>;
+type TRPCListResolvers<AppRouter extends AnyRouter> = Record<string, (client: TRPCClient<AppRouter>) => Bivariant<(input: any) => Promise<TRPCListResult>>>;
 /**
  * Mapping of query procedure name to a tRPC resolver factory.
  */
@@ -733,6 +720,82 @@ declare function createTRPCTransport<AppRouter extends AnyRouter, Mutations exte
   queries?: TRPCQueryResolvers<AppRouter>;
 }): Transport<MutationMapFromResolvers<Mutations>>;
 //#endregion
+//#region src/operation-lifetime.d.ts
+type RetainHandle = Readonly<{
+  dispose(): void;
+}>;
+//#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<{
+  backwardPageLimit?: number;
+  cursors?: ReadonlyArray<string | undefined>;
+  forwardPageLimit?: number;
+  ids: ReadonlyArray<EntityId>;
+  liveAfterIds?: ReadonlyArray<EntityId>;
+  liveBeforeIds?: ReadonlyArray<EntityId>;
+  pagination?: Pagination;
+  pendingAfterIds?: ReadonlyArray<EntityId>;
+  pendingBeforeIds?: ReadonlyArray<EntityId>;
+}>;
+declare class Store {
+  private coverage;
+  private listKeysByOwnerField;
+  private listKeysByReferencedEntity;
+  private lists;
+  private recordReferenceFields;
+  private recordReferencesByTarget;
+  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;
+  replaceListEntityId(previousId: EntityId, nextId: EntityId): void;
+  restoreList(key: string, list?: List): void;
+  collectGarbage(markedRecords: ReadonlySet<EntityId>, markedLists: ReadonlySet<string>, options?: {
+    onRecordDeleted?: (id: EntityId) => void;
+  }): {
+    lists: Set<string>;
+    records: Set<EntityId>;
+  };
+  private deleteList;
+  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;
+  private addListIndexes;
+  private removeListIndexes;
+  private getListReferencedEntityIds;
+  private getRecordFieldReferences;
+  private addRecordFieldReferenceIndex;
+  private removeRecordFieldReferenceIndex;
+  private addRecordReferenceIndexes;
+  private removeRecordReferenceIndexes;
+  private updateRecordReferenceIndexes;
+}
+//#endregion
 //#region src/client.d.ts
 /**
  * Strategy used when resolving a request.
@@ -745,7 +808,15 @@ type RequestOptions = Readonly<{
   mode?: RequestMode;
 }>;
 type FateClientOptions<Roots extends FateRoots, Mutations extends FateMutations> = {
+  /**
+   * Number of recently released requests to keep retained before their records
+   * and lists are eligible for garbage collection.
+   *
+   * @defaultValue 10
+   */
+  gcReleaseBufferSize?: number;
   mutations?: Mutations;
+  onLiveError?: (error: unknown) => void;
   roots: Roots;
   transport: Transport<MutationMapFromDefinitions<Mutations>>;
   types: ReadonlyArray<Omit<TypeConfig, 'getId'> & Partial<{
@@ -766,29 +837,40 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
   private readonly optimisticByEntity;
   private readonly optimisticEntityResolutions;
   private optimisticTokenCounter;
+  private readonly onLiveError;
+  private readonly liveSubscriptions;
+  private readonly liveConnectionInvalidations;
+  private readonly stableRefs;
   private readonly requests;
   private readonly rootRequests;
   private readonly stalledRequests;
+  private gcPending;
+  private gcScheduled;
   readonly store: Store;
+  private readonly operationLifetime;
   private readonly types;
   private readonly transport;
   private readonly viewDataCache;
+  private liveConnectionInvalidationToken;
   readonly actions: MutationActionsFor<Mutations>;
   readonly mutations: MutationFunctionsFor<Mutations>;
   readonly roots: Roots;
   constructor(options: FateClientOptions<Roots, Mutations>);
   private initializeParentLists;
   private registerRootList;
+  private snapshotList;
+  private applyListInsert;
   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;
+  write(type: string, data: AnyRecord, select: ReadonlySet<string>, snapshots?: Map<EntityId, Snapshot>, plan?: SelectionPlan, pathPrefix?: string | null, blockedMask?: FieldMask | null, insert?: InsertPosition, listSnapshots?: Map<string, List>): 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;
+  private stableRefWithViewNames;
   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;
@@ -796,6 +878,17 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
     [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>>;
+  assertLiveViewSupport(): void;
+  assertLiveConnectionSupport(): void;
+  subscribeLiveView<T extends Entity, S extends Selection<T>, V extends View<T, S>>(view: V, ref: ViewRef<T['__typename']>): () => void;
+  subscribeLiveListView<V extends View<any, any>>(view: V, connection: ConnectionMetadata): () => void;
+  private applyLiveConnectionEvent;
+  private invalidateLiveConnection;
+  private deleteConnectionEdge;
+  private insertConnectionEdge;
+  private syncNestedConnectionOwnerField;
+  private getConnectionInsertIndex;
+  private removeEntityFromListState;
   private mergeListState;
   registerPendingOptimisticMutation(entityId: EntityId, promise: Promise<unknown>): void;
   resolveOptimisticEntity(optimisticEntityId: EntityId, resolvedEntityId: EntityId): void;
@@ -811,27 +904,71 @@ declare class FateClient<Roots extends FateRoots, Mutations extends FateMutation
   loadConnection<V extends View<any, any>>(view: V, connection: ConnectionMetadata, args: Record<string, unknown>, options?: {
     direction?: 'forward' | 'backward';
   }): Promise<Readonly<{
+    backwardPageLimit?: number;
     cursors?: ReadonlyArray<string | undefined>;
+    forwardPageLimit?: number;
     ids: ReadonlyArray<EntityId>;
+    liveAfterIds?: ReadonlyArray<EntityId>;
+    liveBeforeIds?: ReadonlyArray<EntityId>;
     pagination?: Pagination;
+    pendingAfterIds?: ReadonlyArray<EntityId>;
+    pendingBeforeIds?: ReadonlyArray<EntityId>;
   }> | undefined>;
   request<R extends Request$1>(request: R, options?: RequestOptions): Promise<RequestResult<Roots, R>>;
+  requestForRender<R extends Request$1>(request: R, options?: RequestOptions): Promise<RequestResult<Roots, R>>;
+  prepareRequestForRender<R extends Request$1>(request: R, options: RequestOptions | undefined): Readonly<{
+    promise: Promise<RequestResult<Roots, R>>;
+    requestKey: string;
+  }>;
+  private requestWithDescriptor;
   releaseRequest(request: Request$1, mode: RequestMode): void;
+  releaseRequestKey(requestKey: string, mode: RequestMode): void;
+  retainRequestKey(requestKey: string, mode?: RequestMode): RetainHandle;
+  /**
+   * Keeps the records and lists reachable from a request alive until the
+   * returned handle is disposed.
+   *
+   * `useRequest` calls this automatically while the component is mounted.
+   * Use it directly for non-React request lifetimes, tests, or preloaded data
+   * that must survive manual garbage collection.
+   */
+  retain(request: Request$1): RetainHandle;
+  private scheduleGarbageCollection;
+  /**
+   * Removes records and lists that are not reachable from retained requests or
+   * the release buffer.
+   *
+   * Garbage collection is scheduled automatically when retained requests are
+   * released. Calling this method manually is mainly useful in tests and custom
+   * memory-management flows.
+   */
+  gc(): void;
+  private executeRequestHandle;
+  private markRecordReferences;
+  private hasActiveOptimisticUpdates;
+  private runPendingGarbageCollection;
   private handleStoreAndNetworkRequest;
   private getRootType;
+  private createRequestDescriptor;
+  getRequestKey(request: Request$1): string;
+  private hasRootListData;
   private executeRequest;
   private hasRequestData;
   getRequestResult<R extends Request$1>(request: R): RequestResult<Roots, R>;
+  private getRequestResultFromDescriptor;
   private fetchByIdAndNormalize;
   private fetchQueryAndNormalize;
   private fetchListAndNormalize;
-  private resolveSelection;
   private writeEntity;
   private linkParentLists;
   private readViewSelection;
   private clearStalledRequestsForEntity;
   private pendingPrefix;
   private pendingKey;
+  private liveSubscriptionKey;
+  private liveConnectionSubscriptionKey;
+  private releaseLiveSubscription;
+  private reportLiveError;
 }
 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
@@ -946,12 +1083,21 @@ type WithNullish<T, R> = R | Nullish<T>;
 type SelectionArgs = Readonly<{
   args: AnyRecord;
 }>;
+type ConnectionLivePolicy = Readonly<{
+  append?: 'edge' | 'visible';
+  prepend?: 'edge' | 'visible';
+}>;
+type ConnectionLiveSelectionPolicy = Readonly<{
+  append?: ConnectionLivePolicy['append'] | string;
+  prepend?: ConnectionLivePolicy['prepend'] | string;
+}>;
 /** Metadata stored alongside connection results to power pagination and cache updates. */
 type ConnectionMetadata = Readonly<{
   args?: AnyRecord;
   field: string;
   hash?: string;
   key: string;
+  live?: ConnectionLivePolicy;
   owner: EntityId;
   procedure: string;
   root?: boolean;
@@ -1001,6 +1147,7 @@ type ConnectionSelectionBase<T extends Entity> = Readonly<{
     cursor?: true;
     node: Selection<T> | View<T, Selection<T>>;
   }>;
+  live?: ConnectionLiveSelectionPolicy;
   pagination?: Readonly<{
     hasNext?: true;
     hasPrevious?: true;
@@ -1048,13 +1195,18 @@ type ViewSnapshot<T extends Entity, S extends Selection<T>> = Readonly<{
   coverage: ReadonlyArray<readonly [id: EntityId, paths: ReadonlySet<string>]>;
   data: ViewData<T, S>;
 }>;
+type ConnectionLikeSelection = {
+  readonly items: {
+    readonly node: unknown;
+  };
+};
 type ConnectionMask<T extends Entity, S> = S extends {
-  items: infer ItemSelection;
-  pagination?: infer PaginationSelection;
+  readonly items: infer ItemSelection;
+  readonly pagination?: infer PaginationSelection;
 } ? {
   items: ItemSelection extends {
-    cursor?: infer CursorSelection;
-    node: unknown;
+    readonly cursor?: infer CursorSelection;
+    readonly node: unknown;
   } ? Array<(CursorSelection extends true ? {
     cursor: string;
   } : Record<string, never>) & {
@@ -1069,7 +1221,7 @@ 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 MaskNonNullish<T, S> = T extends Array<infer U extends Entity> ? S extends true ? Array<U> : S extends ConnectionLikeSelection ? 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;
@@ -1190,4 +1342,4 @@ interface FateThenable<T> extends PromiseLike<T> {
   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 };
+export { ViewRef as A, RequestMode as B, Snapshot as C, ViewData as D, View as E, __FateSelectionBrand as F, createTRPCTransport as G, createClient as H, isViewTag as I, getSelectionPlan as J, AnyProcedure as K, FateMutations as L, ViewSnapshot as M, ViewTag as N, ViewEntity as O, __FateEntityBrand as P, mutation as R, Selection as S, TypeName as T, List as U, RequestOptions as V, Transport as W, NodesItem as _, Entity as a, RequestResult as b, FateThenable as c, MutationDefinition as d, MutationEntity as f, MutationShape as g, MutationResult as h, ConnectionTag as i, ViewSelection as j, ViewEntityName as k, ListItem as l, MutationInput as m, ConnectionMetadata as n, EntityId as o, MutationIdentifier as p, QueryProcedure as q, ConnectionRef as r, FateRoots as s, AnyRecord as t, Mask as u, Pagination as v, TypeConfig as w, RootDefinition as x, Request$1 as y, FateClient as z };

package/lib/vite.d.mts

@@ -0,0 +1,17 @@
+import { Plugin } from "vite";
+
+//#region src/viteTypes.d.ts
+type FateViteTransport = 'native' | 'trpc' | 'void';
+//#endregion
+//#region src/vite.d.ts
+type ClientRuntime = '@nkzw/fate' | 'react-fate';
+type FateVitePluginOptions = {
+  clientModule?: ClientRuntime;
+  generatedFile?: false | string;
+  module: string;
+  transport?: FateViteTransport;
+  tsconfigFile?: false | string;
+};
+declare const fate: (options: FateVitePluginOptions) => Plugin;
+//#endregion
+export { FateVitePluginOptions, type FateViteTransport, fate };