foldkit-remote 0.20.0 → 0.22.0

package/dist/wire-DthPcTM6.d.ts

@@ -0,0 +1,787 @@
+import { a as Requirement, n as RelationRequirement } from "./requirement-D57S2LpH.js";
+import { Schema } from "effect";
+import { Rpc, RpcGroup } from "effect/rpc";
+/**
+ * The read/live protocol version. A batch names the version it speaks and the
+ * server refuses a mismatch with `RemoteProtocolError`, so a shape change never
+ * drifts silently: bump it whenever `ReadRequest` or `LiveRequirement` change.
+ */
+declare const REMOTE_PROTOCOL_VERSION = 5;
+declare const RemoteReadError_base: Schema.Class<RemoteReadError, Schema.TaggedStruct<"RemoteReadError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RemoteReadError extends RemoteReadError_base {}
+declare const RemoteMutationError_base: Schema.Class<RemoteMutationError, Schema.TaggedStruct<"RemoteMutationError", {
+  readonly message: Schema.String;
+  /** The mutation's own `Refusal`, encoded, when the server refused it as one. */
+  readonly refusal: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+declare class RemoteMutationError extends RemoteMutationError_base {}
+declare const RemoteUnreachable_base: Schema.Class<RemoteUnreachable, Schema.TaggedStruct<"Unreachable", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * No answer came back: the request could not be sent, or what came back was
+ * not an answer. The server may or may not have run it, so it is safe to send
+ * again only as the same operation, which a ledgered writer answers from its
+ * record. The outbox sends a durable write again after it (#247).
+ */
+declare class RemoteUnreachable extends RemoteUnreachable_base {}
+declare const RemoteForbidden_base: Schema.Class<RemoteForbidden, Schema.TaggedStruct<"Forbidden", {
+  readonly message: Schema.String;
+  readonly reason: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The server refused who is asking: they may not do this, and asking again
+ * as the same principal is refused again. `reason` is the application's own
+ * words for the person who asked; without it the refusal says nothing of why.
+ */
+declare class RemoteForbidden extends RemoteForbidden_base {}
+declare const RemoteUnauthenticated_base: Schema.Class<RemoteUnauthenticated, Schema.TaggedStruct<"Unauthenticated", {
+  readonly message: Schema.String;
+  readonly reason: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The server could not tell who is asking: a credential was sent and no
+ * longer holds, or none was sent where one is needed. Asking again as the
+ * same caller is refused again; signing in again is the remedy. `reason` is
+ * words for the person who asked; without it the refusal says nothing of why.
+ */
+declare class RemoteUnauthenticated extends RemoteUnauthenticated_base {}
+declare const RemoteLiveError_base: Schema.Class<RemoteLiveError, Schema.TaggedStruct<"RemoteLiveError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RemoteLiveError extends RemoteLiveError_base {}
+declare const RemoteLiveRefused_base: Schema.Class<RemoteLiveRefused, Schema.TaggedStruct<"RemoteLiveRefused", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The server refused a live subscription for what it asks (more ids of one
+ * Entity than `maxIdsPerEntity`), before reading anything. The same
+ * requirements are refused again, so a client does not reconnect it.
+ */
+declare class RemoteLiveRefused extends RemoteLiveRefused_base {}
+declare const RemoteProtocolError_base: Schema.Class<RemoteProtocolError, Schema.TaggedStruct<"RemoteProtocolError", {
+  readonly message: Schema.String;
+  readonly expected: Schema.Number;
+  readonly received: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/** The peer speaks another protocol version; nothing was read. */
+declare class RemoteProtocolError extends RemoteProtocolError_base {}
+/** A page size: a non-negative integer, refused at decode otherwise rather than defaulted. */
+declare const PageSize: Schema.Number;
+declare const WindowSchema: Schema.Struct<{
+  readonly first: Schema.optional<Schema.Number>;
+  readonly last: Schema.optional<Schema.Number>;
+  readonly after: Schema.optional<Schema.String>;
+  readonly before: Schema.optional<Schema.String>;
+}>;
+/** A request may not name more fields of one entity than this; a selection never does. */
+declare const MAX_FIELDS_PER_REQUEST = 256;
+/** A selection may not nest relations deeper than this; the wire refuses more. */
+declare const MAX_RELATION_DEPTH = 8;
+declare const RelationRequest: Schema.Codec<RelationRequirement, RelationRequirement, never, never>;
+declare const ReadRequest: Schema.Codec<Requirement, Requirement>;
+declare const ReadBatch: Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+}>;
+declare const NormalizedEntity: Schema.Struct<{
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+/**
+ * Fields a read asked for that the server answered without, and will not
+ * answer with: the client stops asking. It says nothing about why, so a rule
+ * that withholds a field is not itself on the wire.
+ */
+declare const SettledFields: Schema.Struct<{
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly fields: Schema.$Array<Schema.String>;
+}>;
+declare const ReadBatchResult: Schema.Struct<{
+  readonly entities: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  readonly settled: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>;
+}>;
+/** A read a mutation's answer carries: what was asked, and what came back. */
+declare const AnswerRead: Schema.Struct<{
+  readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+  readonly result: Schema.Struct<{
+    readonly entities: Schema.$Array<Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+    }>>;
+    readonly settled: Schema.$Array<Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly fields: Schema.$Array<Schema.String>;
+    }>>;
+  }>;
+}>;
+/**
+ * One operation's identity across every client: minted where it is first sent
+ * and sent again with each retry of it. Bounded, since a server keys a record
+ * of the write by it.
+ */
+declare const OperationId: Schema.String;
+/** A mutation request may name at most this many entities in `shown`. */
+declare const MAX_SHOWN_ENTITIES = 256;
+/**
+ * What a client reads of one entity's rows: a read request without its id. It
+ * nests as deep as a read request does, so any slice a read asks can be sent.
+ */
+declare const ShownSlice: Schema.Codec<RelationRequirement, RelationRequirement>;
+declare const MutationRequest: Schema.Struct<{
+  /**
+   * This client's id for the request, the same on each retry of it. It is
+   * unique within one client's Model only (a counter there), so it names a
+   * request to that client; `operation` names it to a server.
+   */
+  readonly requestId: Schema.String;
+  /** The operation's identity across clients: what a server keys a record of the write by. */
+  readonly operation: Schema.optional<Schema.String>;
+  readonly mutation: Schema.String;
+  readonly input: Schema.Unknown;
+  /** For a mutation that is a `Write`: the input keys to write, when not all of them. */
+  readonly keys: Schema.optional<Schema.$Array<Schema.String>>;
+  /**
+   * When the reader acted, in milliseconds since the epoch: what the client
+   * predicted the write's time as. A server takes it within its `clockSkew`
+   * of its own clock. Optional, so a client and a server of either age agree.
+   */
+  readonly now: Schema.optional<Schema.Int>;
+  /**
+   * What the client's active reads show of each entity's rows. The server
+   * answers, of each row the mutation names, the shown fields its answer
+   * left out, read as any read is (`MutationResult.read`).
+   */
+  readonly shown: Schema.optional<Schema.$Array<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>>;
+}>;
+declare const LiveEdge: Schema.Struct<{
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly key: Schema.String;
+}>;
+/** A connection change a mutation confirms: the same facts a live event carries, without a cursor. */
+declare const ConnectionChangeSchema: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"Insert">;
+  readonly connection: Schema.String;
+  readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Remove">;
+  readonly connection: Schema.String;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>]>;
+declare const MutationResult: Schema.Struct<{
+  readonly output: Schema.Unknown;
+  readonly entities: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  /** Connection changes the mutation made, applied alongside its entity patches. */
+  readonly connections: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Insert">;
+    readonly connection: Schema.String;
+    readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Remove">;
+    readonly connection: Schema.String;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>]>>>;
+  /** Entities the mutation deleted; the client knows them absent from then on. */
+  readonly deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+  }>>>;
+  /**
+   * A fresh read, after the write, of what the request's `shown` asks of the
+   * rows the answer names: the requirements read and what came back, written
+   * as a read is.
+   */
+  readonly read: Schema.optional<Schema.Struct<{
+    readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+    readonly result: Schema.Struct<{
+      readonly entities: Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+      }>>;
+      readonly settled: Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly fields: Schema.$Array<Schema.String>;
+      }>>;
+    }>;
+  }>>;
+}>;
+declare const QueryRequest: Schema.Struct<{
+  readonly query: Schema.String;
+  readonly input: Schema.Unknown;
+  readonly window: Schema.Struct<{
+    readonly first: Schema.optional<Schema.Number>;
+    readonly last: Schema.optional<Schema.Number>;
+    readonly after: Schema.optional<Schema.String>;
+    readonly before: Schema.optional<Schema.String>;
+  }>;
+  /**
+   * What to read of each item, as the relation slice a read asks the server
+   * for. Absent for a query run without one: the response carries only edges,
+   * and the client's read entry fetches fields in a second round trip.
+   */
+  readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+}>;
+/** A live subscription may watch no more lists than this; each is run again every tick. */
+declare const MAX_LIVE_QUERIES = 32;
+declare const LiveRequirement: Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requirements: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+  /** Lists read live (`Data.query(…, { live: true })`), each as its read sends it. */
+  readonly queries: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly query: Schema.String;
+    readonly input: Schema.Unknown;
+    readonly window: Schema.Struct<{
+      readonly first: Schema.optional<Schema.Number>;
+      readonly last: Schema.optional<Schema.Number>;
+      readonly after: Schema.optional<Schema.String>;
+      readonly before: Schema.optional<Schema.String>;
+    }>;
+    /**
+     * What to read of each item, as the relation slice a read asks the server
+     * for. Absent for a query run without one: the response carries only edges,
+     * and the client's read entry fetches fields in a second round trip.
+     */
+    readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+  }>>>;
+  /** Resume cursor; events at or before it are duplicates. */
+  readonly after: Schema.Number;
+}>;
+/**
+ * A live change. Entity changes update the store; connection changes alter
+ * membership and ordering; both carry a per-stream cursor.
+ */
+declare const LiveChange: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityPatched">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly changed: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityDeleted">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInsert">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionRemove">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInvalidate">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+}>]>;
+declare const Read: Rpc.Rpc<"FoldkitRemoteRead", Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+}>, Schema.Struct<{
+  readonly entities: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  readonly settled: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>;
+}>, Schema.Union<readonly [typeof RemoteReadError, typeof RemoteProtocolError, typeof RemoteUnauthenticated]>, never, never>;
+declare const Mutate: Rpc.Rpc<"FoldkitRemoteMutate", Schema.Struct<{
+  /**
+   * This client's id for the request, the same on each retry of it. It is
+   * unique within one client's Model only (a counter there), so it names a
+   * request to that client; `operation` names it to a server.
+   */
+  readonly requestId: Schema.String;
+  /** The operation's identity across clients: what a server keys a record of the write by. */
+  readonly operation: Schema.optional<Schema.String>;
+  readonly mutation: Schema.String;
+  readonly input: Schema.Unknown;
+  /** For a mutation that is a `Write`: the input keys to write, when not all of them. */
+  readonly keys: Schema.optional<Schema.$Array<Schema.String>>;
+  /**
+   * When the reader acted, in milliseconds since the epoch: what the client
+   * predicted the write's time as. A server takes it within its `clockSkew`
+   * of its own clock. Optional, so a client and a server of either age agree.
+   */
+  readonly now: Schema.optional<Schema.Int>;
+  /**
+   * What the client's active reads show of each entity's rows. The server
+   * answers, of each row the mutation names, the shown fields its answer
+   * left out, read as any read is (`MutationResult.read`).
+   */
+  readonly shown: Schema.optional<Schema.$Array<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>>;
+}>, Schema.Struct<{
+  readonly output: Schema.Unknown;
+  readonly entities: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  /** Connection changes the mutation made, applied alongside its entity patches. */
+  readonly connections: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Insert">;
+    readonly connection: Schema.String;
+    readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Remove">;
+    readonly connection: Schema.String;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>]>>>;
+  /** Entities the mutation deleted; the client knows them absent from then on. */
+  readonly deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+  }>>>;
+  /**
+   * A fresh read, after the write, of what the request's `shown` asks of the
+   * rows the answer names: the requirements read and what came back, written
+   * as a read is.
+   */
+  readonly read: Schema.optional<Schema.Struct<{
+    readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+    readonly result: Schema.Struct<{
+      readonly entities: Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+      }>>;
+      readonly settled: Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly fields: Schema.$Array<Schema.String>;
+      }>>;
+    }>;
+  }>>;
+}>, Schema.Union<readonly [typeof RemoteMutationError, typeof RemoteForbidden, typeof RemoteUnauthenticated]>, never, never>;
+declare const Live: Rpc.Rpc<"FoldkitRemoteLive", Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requirements: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+  /** Lists read live (`Data.query(…, { live: true })`), each as its read sends it. */
+  readonly queries: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly query: Schema.String;
+    readonly input: Schema.Unknown;
+    readonly window: Schema.Struct<{
+      readonly first: Schema.optional<Schema.Number>;
+      readonly last: Schema.optional<Schema.Number>;
+      readonly after: Schema.optional<Schema.String>;
+      readonly before: Schema.optional<Schema.String>;
+    }>;
+    /**
+     * What to read of each item, as the relation slice a read asks the server
+     * for. Absent for a query run without one: the response carries only edges,
+     * and the client's read entry fetches fields in a second round trip.
+     */
+    readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+  }>>>;
+  /** Resume cursor; events at or before it are duplicates. */
+  readonly after: Schema.Number;
+}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityPatched">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly changed: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityDeleted">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInsert">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionRemove">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInvalidate">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+}>]>, Schema.Union<readonly [typeof RemoteLiveError, typeof RemoteLiveRefused, typeof RemoteProtocolError, typeof RemoteUnauthenticated]>>, Schema.Never, never, never>;
+declare const RemoteQueryError_base: Schema.Class<RemoteQueryError, Schema.TaggedStruct<"RemoteQueryError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RemoteQueryError extends RemoteQueryError_base {}
+declare const WireBoundary: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"Terminal">;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Cursor">;
+  readonly cursor: Schema.String;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Unknown">;
+}>]>;
+declare const QueryEdge: Schema.Struct<{
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly key: Schema.String;
+}>;
+declare const QueryResult: Schema.Struct<{
+  readonly edges: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>>;
+  readonly start: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  readonly end: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  /**
+   * The selected fields of the page's items, in the same shape a read batch
+   * returns. Absent from a server that predates payload planning: the client
+   * reads it as empty and fetches fields as before.
+   */
+  readonly entities: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>>;
+  readonly settled: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>>;
+}>;
+declare const QueryRpc: Rpc.Rpc<"FoldkitRemoteQuery", Schema.Struct<{
+  readonly query: Schema.String;
+  readonly input: Schema.Unknown;
+  readonly window: Schema.Struct<{
+    readonly first: Schema.optional<Schema.Number>;
+    readonly last: Schema.optional<Schema.Number>;
+    readonly after: Schema.optional<Schema.String>;
+    readonly before: Schema.optional<Schema.String>;
+  }>;
+  /**
+   * What to read of each item, as the relation slice a read asks the server
+   * for. Absent for a query run without one: the response carries only edges,
+   * and the client's read entry fetches fields in a second round trip.
+   */
+  readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+}>, Schema.Struct<{
+  readonly edges: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>>;
+  readonly start: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  readonly end: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  /**
+   * The selected fields of the page's items, in the same shape a read batch
+   * returns. Absent from a server that predates payload planning: the client
+   * reads it as empty and fetches fields as before.
+   */
+  readonly entities: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>>;
+  readonly settled: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>>;
+}>, Schema.Union<readonly [typeof RemoteQueryError, typeof RemoteUnauthenticated]>, never, never>;
+declare const RemoteRpc: RpcGroup.RpcGroup<Rpc.Rpc<"FoldkitRemoteLive", Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requirements: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+  /** Lists read live (`Data.query(…, { live: true })`), each as its read sends it. */
+  readonly queries: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly query: Schema.String;
+    readonly input: Schema.Unknown;
+    readonly window: Schema.Struct<{
+      readonly first: Schema.optional<Schema.Number>;
+      readonly last: Schema.optional<Schema.Number>;
+      readonly after: Schema.optional<Schema.String>;
+      readonly before: Schema.optional<Schema.String>;
+    }>;
+    /**
+     * What to read of each item, as the relation slice a read asks the server
+     * for. Absent for a query run without one: the response carries only edges,
+     * and the client's read entry fetches fields in a second round trip.
+     */
+    readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+  }>>>;
+  /** Resume cursor; events at or before it are duplicates. */
+  readonly after: Schema.Number;
+}>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityPatched">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+  readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  readonly changed: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"EntityDeleted">;
+  readonly cursor: Schema.Number;
+  readonly entity: Schema.String;
+  readonly id: Schema.String;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInsert">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionRemove">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+  readonly edge: Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ConnectionInvalidate">;
+  readonly cursor: Schema.Number;
+  readonly connection: Schema.String;
+}>]>, Schema.Union<readonly [typeof RemoteLiveError, typeof RemoteLiveRefused, typeof RemoteProtocolError, typeof RemoteUnauthenticated]>>, Schema.Never, never, never> | Rpc.Rpc<"FoldkitRemoteMutate", Schema.Struct<{
+  /**
+   * This client's id for the request, the same on each retry of it. It is
+   * unique within one client's Model only (a counter there), so it names a
+   * request to that client; `operation` names it to a server.
+   */
+  readonly requestId: Schema.String;
+  /** The operation's identity across clients: what a server keys a record of the write by. */
+  readonly operation: Schema.optional<Schema.String>;
+  readonly mutation: Schema.String;
+  readonly input: Schema.Unknown;
+  /** For a mutation that is a `Write`: the input keys to write, when not all of them. */
+  readonly keys: Schema.optional<Schema.$Array<Schema.String>>;
+  /**
+   * When the reader acted, in milliseconds since the epoch: what the client
+   * predicted the write's time as. A server takes it within its `clockSkew`
+   * of its own clock. Optional, so a client and a server of either age agree.
+   */
+  readonly now: Schema.optional<Schema.Int>;
+  /**
+   * What the client's active reads show of each entity's rows. The server
+   * answers, of each row the mutation names, the shown fields its answer
+   * left out, read as any read is (`MutationResult.read`).
+   */
+  readonly shown: Schema.optional<Schema.$Array<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>>;
+}>, Schema.Struct<{
+  readonly output: Schema.Unknown;
+  readonly entities: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  /** Connection changes the mutation made, applied alongside its entity patches. */
+  readonly connections: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Insert">;
+    readonly connection: Schema.String;
+    readonly position: Schema.Union<readonly [Schema.Literal<"prepend">, Schema.Literal<"append">]>;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Remove">;
+    readonly connection: Schema.String;
+    readonly edge: Schema.Struct<{
+      readonly entity: Schema.String;
+      readonly id: Schema.String;
+      readonly key: Schema.String;
+    }>;
+  }>]>>>;
+  /** Entities the mutation deleted; the client knows them absent from then on. */
+  readonly deleted: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+  }>>>;
+  /**
+   * A fresh read, after the write, of what the request's `shown` asks of the
+   * rows the answer names: the requirements read and what came back, written
+   * as a read is.
+   */
+  readonly read: Schema.optional<Schema.Struct<{
+    readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+    readonly result: Schema.Struct<{
+      readonly entities: Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+      }>>;
+      readonly settled: Schema.$Array<Schema.Struct<{
+        readonly entity: Schema.String;
+        readonly id: Schema.String;
+        readonly fields: Schema.$Array<Schema.String>;
+      }>>;
+    }>;
+  }>>;
+}>, Schema.Union<readonly [typeof RemoteMutationError, typeof RemoteForbidden, typeof RemoteUnauthenticated]>, never, never> | Rpc.Rpc<"FoldkitRemoteQuery", Schema.Struct<{
+  readonly query: Schema.String;
+  readonly input: Schema.Unknown;
+  readonly window: Schema.Struct<{
+    readonly first: Schema.optional<Schema.Number>;
+    readonly last: Schema.optional<Schema.Number>;
+    readonly after: Schema.optional<Schema.String>;
+    readonly before: Schema.optional<Schema.String>;
+  }>;
+  /**
+   * What to read of each item, as the relation slice a read asks the server
+   * for. Absent for a query run without one: the response carries only edges,
+   * and the client's read entry fetches fields in a second round trip.
+   */
+  readonly select: Schema.optional<Schema.Codec<RelationRequirement, RelationRequirement, never, never>>;
+}>, Schema.Struct<{
+  readonly edges: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly key: Schema.String;
+  }>>;
+  readonly start: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  readonly end: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Terminal">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Cursor">;
+    readonly cursor: Schema.String;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unknown">;
+  }>]>;
+  /**
+   * The selected fields of the page's items, in the same shape a read batch
+   * returns. Absent from a server that predates payload planning: the client
+   * reads it as empty and fetches fields as before.
+   */
+  readonly entities: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>>;
+  readonly settled: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>>;
+}>, Schema.Union<readonly [typeof RemoteQueryError, typeof RemoteUnauthenticated]>, never, never> | Rpc.Rpc<"FoldkitRemoteRead", Schema.Struct<{
+  readonly version: Schema.Number;
+  readonly requests: Schema.$Array<Schema.Codec<Requirement, Requirement, never, never>>;
+}>, Schema.Struct<{
+  readonly entities: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly values: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  readonly settled: Schema.$Array<Schema.Struct<{
+    readonly entity: Schema.String;
+    readonly id: Schema.String;
+    readonly fields: Schema.$Array<Schema.String>;
+  }>>;
+}>, Schema.Union<readonly [typeof RemoteReadError, typeof RemoteProtocolError, typeof RemoteUnauthenticated]>, never, never>>;
+export { RemoteMutationError as A, WireBoundary as B, ReadBatch as C, RemoteForbidden as D, RelationRequest as E, RemoteUnauthenticated as F, RemoteUnreachable as I, SettledFields as L, RemoteQueryError as M, RemoteReadError as N, RemoteLiveError as O, RemoteRpc as P, ShownSlice as R, Read as S, ReadRequest as T, QueryEdge as _, LiveEdge as a, QueryRpc as b, MAX_LIVE_QUERIES as c, Mutate as d, MutationRequest as f, PageSize as g, OperationId as h, LiveChange as i, RemoteProtocolError as j, RemoteLiveRefused as k, MAX_RELATION_DEPTH as l, NormalizedEntity as m, ConnectionChangeSchema as n, LiveRequirement as o, MutationResult as p, Live as r, MAX_FIELDS_PER_REQUEST as s, AnswerRead as t, MAX_SHOWN_ENTITIES as u, QueryRequest as v, ReadBatchResult as w, REMOTE_PROTOCOL_VERSION as x, QueryResult as y, WindowSchema as z };
+//# sourceMappingURL=wire-DthPcTM6.d.ts.map