@arkiv-network/sdk 0.8.1-dev.1 → 0.9.0-next.2

package/dist/changeOwnership-gXf-lBqI.d.ts

@@ -0,0 +1,1160 @@
+import { c as ResolvedCreationFlags, i as SaltInput, s as CreationFlags } from "./index-C4zZqJ9S.js";
+import { t as Expiry } from "./expiry-S2PUL8Hg.js";
+import { C as IndexedColumnName, E as PatchEntityValues, O as Schema, R as TagOf, S as CreateEntityValues, T as OptionalColumnName, _ as Attributes, _t as TypeTag, bt as ValueOf, g as AttributeSchema, gt as StrValue, mt as IndexableValue, ot as ArkivValue, pt as IndexableTypeTag, tt as AnyColumn, x as ColumnsOf } from "./index-DLb7BfIw.js";
+import { Account, Address, Chain, Client, Hash, Hex, RpcSchema, Transport } from "viem";
+
+//#region src/types/rpcSchema.d.ts
+
+/**
+ * An attribute as the node renders it: the name, the type **tag** (not the wire typeId), and the
+ * value in the JSON encoding that type prescribes — a JSON number for `i32`, a `0x` QUANTITY for
+ * `u64` and `u256`, a decimal string for `dec`, `0x` DATA for the byte-shaped types (`bytes`
+ * included), and a string for `str`.
+ *
+ * The encoding follows the *declared type*, never the magnitude, so a decoder dispatches on `type`
+ * and never has to guess from the shape of the value.
+ */
+type RpcAttribute = {
+  name: string;
+  type: string;
+  value: unknown;
+};
+/**
+ * An entry of the `attributeSchema` projection — a name, its type, and whether the node indexes
+ * it, with no value.
+ */
+type RpcAttributeSchemaEntry = {
+  name: string;
+  type: string;
+  indexed?: boolean;
+};
+/**
+ * The `creationFlags` projection.
+ */
+type RpcCreationFlags = {
+  readonly?: boolean;
+  permissionlessExtension?: boolean;
+  raw: number;
+};
+/**
+ * An entity as `arkiv_query` returns it. Every field is present only if it was selected, so all of
+ * them are optional here — {@link RpcSelect} is what decides which arrive.
+ */
+type RpcEntity = {
+  key?: Hex;
+  owner?: Hex;
+  creator?: Hex;
+  createdAt?: Hex;
+  updatedAt?: Hex;
+  expiresAt?: Hex;
+  creationFlags?: RpcCreationFlags | number;
+  attributeSchema?: RpcAttributeSchemaEntry[];
+  attributes?: RpcAttribute[];
+};
+/**
+ * The `select` projection: flat, per-field booleans. Everything except `key` defaults to **off**,
+ * so a query asks for exactly what it needs and nothing more.
+ *
+ * `attributes` is the one field with a third form: `true` for every attribute, or a map of names
+ * for a subset.
+ */
+type RpcSelect = {
+  key?: boolean;
+  owner?: boolean;
+  creator?: boolean;
+  createdAt?: boolean;
+  updatedAt?: boolean;
+  expiresAt?: boolean;
+  creationFlags?: boolean;
+  attributeSchema?: boolean;
+  attributes?: boolean | Record<string, boolean>;
+  /**
+   * Not a field of each entity but of the page: the number of entities the query matches at the
+   * block, regardless of `limit` and `cursor`, returned as the response's `count`.
+   */
+  count?: boolean;
+};
+/** The second parameter of `arkiv_query` — what to return, and where in the results to start. */
+type RpcQueryOptions = {
+  /** Block height to read at, as a hex quantity. Defaults to the head, and must be within the node's retained range. */
+  atBlock?: Hex;
+  /** What to return. Defaults to `{ key: true }`. */
+  select?: RpcSelect;
+  /** Page size, as a hex quantity. Node maximum is 100. */
+  limit?: Hex;
+  /** Opaque cursor from a previous response; bound to that query, block and selection. */
+  cursor?: string;
+};
+type ArkivRpcSchema = [{
+  Method: "arkiv_query";
+  Parameters?: [query: string, queryOptions?: RpcQueryOptions];
+  ReturnType: {
+    data: RpcEntity[];
+    blockNumber: Hex;
+    /** Omitted when no pages remain. */
+    cursor?: string;
+    /** How many entities the query matches, as a hex quantity. Present only when selected. */
+    count?: Hex;
+  };
+}, {
+  Method: "arkiv_getEntity";
+  Parameters: [entityKey: Hex];
+  /** Every field except `attributeSchema`, or `null` if no live entity has the key. */
+  ReturnType: RpcEntity | null;
+}, {
+  Method: "arkiv_getBlockTiming";
+  Parameters?: [];
+  ReturnType: {
+    current_block: bigint;
+    current_block_time: number;
+    duration: number;
+  };
+}];
+//#endregion
+//#region src/clients/baseClient.d.ts
+type ArkivClient<transport extends Transport = Transport, chain extends Chain | undefined = Chain | undefined, accountOrAddress extends Account | undefined = Account | undefined, rpcSchema extends RpcSchema | undefined = ArkivRpcSchema> = Client<transport, chain, accountOrAddress, rpcSchema>;
+//#endregion
+//#region src/actions/public/getBlockTiming.d.ts
+type GetBlockTimingReturnType = {
+  currentBlock: bigint;
+  currentBlockTime: number;
+  blockDuration: number;
+};
+//#endregion
+//#region src/actions/public/predictEntityKeys.d.ts
+/**
+ * A key a create will be given, together with the salt that mints it.
+ *
+ * The two travel as a pair because neither is any use alone: a create defaults to a *random* salt,
+ * so the key only comes out as predicted if that same create carries this salt.
+ */
+type PredictedEntityKey = {
+  /** The key the create will be given. */
+  key: Hex;
+  /**
+   * The salt the create must carry for its key to come out as {@link PredictedEntityKey.key}.
+   * Always a plain `uint128` — a requested {@link NO_SALT} comes back as the `0n` it resolves to,
+   * which a create accepts just the same.
+   */
+  salt: bigint;
+};
+/** Parameters for `client.predictEntityKeys`. */
+type PredictEntityKeysParameters<TCount extends number = number, TSalts extends readonly SaltInput[] | undefined = readonly SaltInput[] | undefined> = {
+  /** The account that will sign the creates. Its nonce is what the keys are derived from. */
+  owner: Address;
+  /**
+   * How many creates the batch will carry. Ignored when `salts` is given, which already says how
+   * many there are.
+   *
+   * A literal count comes back as a fixed-length tuple, so `count: 2` destructures into two named
+   * pairs without a cast.
+   */
+  count?: TCount | undefined;
+  /**
+   * The salt each create will carry, in batch order. Defaults to `count` fresh random salts —
+   * either way each key comes back paired with the salt that mints it. Pass {@link NO_SALT} in a
+   * slot whose create opts out of salting.
+   */
+  salts?: TSalts;
+};
+/**
+ * The keys a batch would mint, in batch order, each paired with its salt.
+ *
+ * The length follows the request whenever it is known statically: a literal `count`, or a `salts`
+ * tuple, gives a fixed-length tuple; a count computed at runtime gives a plain array.
+ *
+ * `TSalts` is wrapped in a tuple to stop the conditional distributing over it. Left naked, the
+ * `readonly SaltInput[] | undefined` default would take both branches and union a tuple with an
+ * array, which widens the length straight back to `number`.
+ */
+type PredictEntityKeysReturnType<TCount extends number = number, TSalts extends readonly SaltInput[] | undefined = readonly SaltInput[] | undefined> = [TSalts] extends [readonly SaltInput[]] ? { -readonly [Index in keyof TSalts]: PredictedEntityKey } : Repeat<PredictedEntityKey, TCount>;
+/**
+ * A tuple of `TLength` × `T`, or a plain array when the length is only known at runtime.
+ *
+ * Written tail-recursively so TypeScript can build the batch sizes anyone would actually send.
+ */
+type Repeat<T$1, TLength extends number, TAcc extends T$1[] = []> = number extends TLength ? T$1[] : TAcc["length"] extends TLength ? TAcc : Repeat<T$1, TLength, [...TAcc, T$1]>;
+/**
+ * Works out the keys an account's next creates will be given, before sending them.
+ *
+ * A key is `keccak256(chainId ++ registry ++ owner ++ nonce ++ salt)`. Everything but the nonce is
+ * known to the caller, and the nonce is read here — so a batch can reference a key it is about to
+ * mint, storing it as a `key` attribute on a sibling entity created in the same transaction.
+ *
+ * Each key arrives paired with its salt, and the create must be given that salt: a create left to
+ * pick its own salt picks a random one, which mints a different key.
+ *
+ * The prediction is valid only while nothing else from this owner is in flight. Every create that
+ * lands first takes the nonce with it and moves these keys. For a key you can rely on
+ * unconditionally, read it back from the create instead — `createEntity` and `executeBatch`
+ * report the keys the engine actually minted.
+ *
+ * @param parameters - Owner, and either a count or the salts. {@link PredictEntityKeysParameters}
+ * @returns One `{ key, salt }` pair per create, in batch order. {@link PredictEntityKeysReturnType}
+ *
+ * @example A batch whose second entity points at its first.
+ * import { defineSchema, key, str } from "@arkiv-network/sdk/schema"
+ *
+ * const Nodes = defineSchema("nodes", { name: str(), parent: key().indexed().optional() })
+ *
+ * const [parent, child] = await client.predictEntityKeys({ owner: account.address, count: 2 })
+ * await wallet.executeBatch({
+ *   creates: [
+ *     { schema: Nodes, values: { name: "root" }, expiration, salt: parent.salt },
+ *     {
+ *       schema: Nodes,
+ *       values: { name: "leaf", parent: key(parent.key) },
+ *       expiration,
+ *       salt: child.salt,
+ *     },
+ *   ],
+ * })
+ */
+//#endregion
+//#region src/query/expression.d.ts
+/**
+ * The comparison operators the query language defines. Every indexable type accepts all of them;
+ * `<` `<=` `>` `>=` compare in index order — numerically for `i32`, `u64`, `u256` and `dec`,
+ * `false < true` for `bool`, and by unsigned bytes for `str`, `bytes32`, `addr` and `key`.
+ */
+type ComparisonOperator = "=" | "!=" | "<" | "<=" | ">" | ">=";
+/**
+ * A value a predicate can compare against: a value of any indexable type, or a bare boolean,
+ * number, bigint or string. `bytes` is excluded — it is never indexed, so never filterable.
+ */
+type PredicateValue = IndexableValue | boolean | number | bigint | string;
+/**
+ * `between`'s check that both bounds have one type — `unknown` when they do, and otherwise an
+ * object whose one property is named after the problem. No value has that property, so the
+ * compiler reports the sentence as the property it is missing.
+ */
+type SameTypeCheck<L, H> = [TagOf<L>, TagOf<H>] extends [TagOf<H>, TagOf<L>] ? unknown : { [K in `BETWEEN bounds must have one type, got ${TagOf<L>} and ${TagOf<H>}`]: never };
+/**
+ * The attribute a predicate names, and the type it asserts — `never` when it asserts none, as
+ * `EXISTS` does. Carried by an {@link Expression} at the type level only, so a query against a
+ * schema can be checked at compile time: every name must be an indexed column, and every type the
+ * column's.
+ */
+type AttributeRef = {
+  readonly name: string;
+  readonly type: IndexableTypeTag;
+};
+declare const refs: unique symbol;
+/** The type-level record of the attributes an expression names. Never present at runtime. */
+type Refs<R$1 extends AttributeRef> = {
+  readonly [refs]?: R$1;
+};
+/** A comparison between an attribute and a typed literal. */
+interface ComparisonNode<R$1 extends AttributeRef = AttributeRef> extends Refs<R$1> {
+  readonly kind: "comparison";
+  readonly name: string;
+  readonly operator: ComparisonOperator;
+  readonly value: IndexableValue;
+}
+/** An inclusive range test, `name BETWEEN low AND high`. Both bounds have one type. */
+interface BetweenNode<R$1 extends AttributeRef = AttributeRef> extends Refs<R$1> {
+  readonly kind: "between";
+  readonly name: string;
+  readonly low: IndexableValue;
+  readonly high: IndexableValue;
+}
+/** A `STARTSWITH` prefix test, the language's only pattern operator. */
+interface StartsWithNode<R$1 extends AttributeRef = AttributeRef> extends Refs<R$1> {
+  readonly kind: "startsWith";
+  readonly name: string;
+  readonly value: StrValue;
+}
+/** An `EXISTS(name)` test — true when the attribute is set with any type. */
+interface ExistsNode<R$1 extends AttributeRef = AttributeRef> extends Refs<R$1> {
+  readonly kind: "exists";
+  readonly name: string;
+}
+/** A `TYPEOF(name) = tag` test. */
+interface TypeOfNode<R$1 extends AttributeRef = AttributeRef> extends Refs<R$1> {
+  readonly kind: "typeOf";
+  readonly name: string;
+  readonly tag: IndexableTypeTag;
+}
+/** The complement of an expression, evaluated against the active-entity set. */
+interface NotNode<R$1 extends AttributeRef = AttributeRef> extends Refs<R$1> {
+  readonly kind: "not";
+  readonly expression: Expression;
+}
+/** A conjunction. */
+interface AndNode<R$1 extends AttributeRef = AttributeRef> extends Refs<R$1> {
+  readonly kind: "and";
+  readonly expressions: readonly Expression[];
+}
+/** A disjunction. */
+interface OrNode<R$1 extends AttributeRef = AttributeRef> extends Refs<R$1> {
+  readonly kind: "or";
+  readonly expressions: readonly Expression[];
+}
+/**
+ * A query expression: an immutable tree built by the combinators below, whose `toString()` is the
+ * exact query string sent over the wire.
+ *
+ * @typeParam R - The attributes the expression names, as {@link AttributeRef}s — inferred by the
+ * combinators, and checked against the schema by `select(...).from(schema).where(...)`.
+ *
+ * @example
+ * const q = and(gte("level", i32(10)), or(eq("status", str("open")), not(exists("closedAt"))))
+ * String(q) // level >= i32(10) AND (status = str('open') OR NOT EXISTS(closedAt))
+ */
+type Expression<R$1 extends AttributeRef = AttributeRef> = ComparisonNode<R$1> | BetweenNode<R$1> | StartsWithNode<R$1> | ExistsNode<R$1> | TypeOfNode<R$1> | NotNode<R$1> | AndNode<R$1> | OrNode<R$1>;
+/** The attributes an expression names — the `R` of an {@link Expression}. */
+type RefsOf<E> = E extends Refs<infer R> ? Exclude<R, undefined> : never;
+/** The reference a comparison against `V` makes to `N`. */
+type ValueRef<N$1 extends string, V> = {
+  readonly name: N$1;
+  readonly type: TagOf<V> & IndexableTypeTag;
+};
+/**
+ * The system attributes a query may filter on, and the type each one carries.
+ *
+ * Every other system attribute (`$createdAt`, `$updatedAt`, `$creationFlags`) is returned in
+ * query results — selected and read back as `createdAt`, `updatedAt` and `creationFlags` — but is
+ * not indexed, so it cannot appear in a predicate.
+ */
+declare const QUERYABLE_SYSTEM_ATTRIBUTES: {
+  readonly $key: "key";
+  readonly $owner: "addr";
+  readonly $creator: "addr";
+  readonly $expiresAt: "u64";
+};
+type SystemAttributeName = keyof typeof QUERYABLE_SYSTEM_ATTRIBUTES;
+/** The references a filter on a system attribute makes — each with its fixed type. */
+type SystemAttributeRef = { [N in SystemAttributeName]: {
+  readonly name: N;
+  readonly type: (typeof QUERYABLE_SYSTEM_ATTRIBUTES)[N];
+} }[SystemAttributeName];
+/**
+ * The references a filter through schema `S` may make: each indexed column with its declared
+ * type, and the queryable system attributes with theirs. An {@link Expression} naming anything else
+ * is a compile error in `select(...).from(S).where(...)`.
+ */
+type SchemaRef<S extends Schema> = { [K in IndexedColumnName<S>]: {
+  readonly name: K;
+  readonly type: ColumnsOf<S>[K]["type"] & IndexableTypeTag;
+} }[IndexedColumnName<S>] | SystemAttributeRef;
+/**
+ * Attribute equals value — set with this exact type, and holding this value.
+ *
+ * Bare booleans, numbers, bigints and strings take the same default types they take when written
+ * (`number` is an `i32`, `bigint` a `u256`, `string` a `str`); anything else names its type.
+ *
+ * @throws {InvalidAttributeNameError} If the name is outside the attribute name grammar.
+ * @throws {InvalidPredicateError} If the name starts with `$` but is not a queryable system
+ * attribute, a system attribute is compared against the wrong type, or the value is `bytes`.
+ *
+ * @example
+ * eq("status", str("open"))     // status = str('open')
+ * eq("flagged", true)           // flagged = true
+ * eq("$owner", addr(account))   // $owner = addr(0xd8dA…)
+ */
+declare function eq<N$1 extends string, V extends PredicateValue>(name: N$1, value: V): ComparisonNode<ValueRef<N$1, V>>;
+/**
+ * Attribute is set with this type and holds a **different** value.
+ *
+ * This is typed value-negation, not the complement: an entity that never set the attribute, or set
+ * it with another type, does not match. Use `not(eq(...))` for the full complement.
+ *
+ * @throws {InvalidAttributeNameError} If the name is outside the attribute name grammar.
+ * @throws {InvalidPredicateError} If the name starts with `$` but is not a queryable system
+ * attribute, a system attribute is compared against the wrong type, or the value is `bytes`.
+ *
+ * @example
+ * ne("status", str("closed"))          // status != str('closed')
+ * not(eq("status", str("closed")))     // NOT status = str('closed') — also matches entities with no status
+ */
+declare function ne<N$1 extends string, V extends PredicateValue>(name: N$1, value: V): ComparisonNode<ValueRef<N$1, V>>;
+/**
+ * Attribute is greater than value, in index order — see {@link ComparisonOperator}.
+ *
+ * @throws {InvalidAttributeNameError} If the name is outside the attribute name grammar.
+ * @throws {InvalidPredicateError} If the name starts with `$` but is not a queryable system
+ * attribute, a system attribute is compared against the wrong type, or the value is `bytes`.
+ *
+ * @example
+ * gt("level", i32(10))              // level > i32(10)
+ * gt("$expiresAt", u64(1_200_000n)) // $expiresAt > u64(1200000)
+ */
+declare function gt<N$1 extends string, V extends PredicateValue>(name: N$1, value: V): ComparisonNode<ValueRef<N$1, V>>;
+/**
+ * Attribute is greater than or equal to value, in index order — see {@link ComparisonOperator}.
+ *
+ * @throws {InvalidAttributeNameError} If the name is outside the attribute name grammar.
+ * @throws {InvalidPredicateError} If the name starts with `$` but is not a queryable system
+ * attribute, a system attribute is compared against the wrong type, or the value is `bytes`.
+ *
+ * @example
+ * gte("score", dec("3.5")) // score >= dec(3.5)
+ */
+declare function gte<N$1 extends string, V extends PredicateValue>(name: N$1, value: V): ComparisonNode<ValueRef<N$1, V>>;
+/**
+ * Attribute is less than value, in index order — see {@link ComparisonOperator}.
+ *
+ * @throws {InvalidAttributeNameError} If the name is outside the attribute name grammar.
+ * @throws {InvalidPredicateError} If the name starts with `$` but is not a queryable system
+ * attribute, a system attribute is compared against the wrong type, or the value is `bytes`.
+ *
+ * @example
+ * lt("level", i32(10)) // level < i32(10)
+ */
+declare function lt<N$1 extends string, V extends PredicateValue>(name: N$1, value: V): ComparisonNode<ValueRef<N$1, V>>;
+/**
+ * Attribute is less than or equal to value, in index order — see {@link ComparisonOperator}.
+ *
+ * @throws {InvalidAttributeNameError} If the name is outside the attribute name grammar.
+ * @throws {InvalidPredicateError} If the name starts with `$` but is not a queryable system
+ * attribute, a system attribute is compared against the wrong type, or the value is `bytes`.
+ *
+ * @example
+ * lte("score", dec("5")) // score <= dec(5)
+ */
+declare function lte<N$1 extends string, V extends PredicateValue>(name: N$1, value: V): ComparisonNode<ValueRef<N$1, V>>;
+/**
+ * Attribute lies between two values, **inclusive** at both ends: it matches exactly what
+ * `and(gte(name, low), lte(name, high))` matches, in one predicate. Both bounds must have one type,
+ * and a `low` above `high` matches nothing.
+ *
+ * @throws {InvalidAttributeNameError} If the name is outside the attribute name grammar.
+ * @throws {InvalidPredicateError} If the bounds have different types, the name starts with `$` but
+ * is not a queryable system attribute, a system attribute is compared against the wrong type, or a
+ * bound is `bytes`.
+ *
+ * @example
+ * between("score", dec("3.5"), dec("5"))  // score BETWEEN dec(3.5) AND dec(5)
+ * between("$expiresAt", u64(100n), u64(200n))
+ */
+declare function between<N$1 extends string, L extends PredicateValue, H extends PredicateValue>(name: N$1, low: L, high: H & SameTypeCheck<L, H>): BetweenNode<ValueRef<N$1, L>>;
+/**
+ * Attribute is a `str` beginning with this prefix.
+ *
+ * The match is on **raw UTF-8 bytes** with no normalization — it is the index encoding, so
+ * `startsWith("name", "é")` matches only the same byte sequence, not another normal form of it.
+ *
+ * @param prefix - The prefix, as a bare string or a `str` value.
+ * @throws {InvalidAttributeNameError} If the name is outside the attribute name grammar.
+ * @throws {InvalidPredicateError} If the name starts with `$` but is not a queryable system
+ * attribute.
+ * @throws {UnsupportedOperatorError} If given a value that is not a `str`, or a system attribute
+ * (none of which is a `str`).
+ *
+ * @example
+ * startsWith("desc", "ab") // desc STARTSWITH str('ab')
+ */
+declare function startsWith<N$1 extends string>(name: N$1, prefix: string | StrValue): StartsWithNode<{
+  readonly name: N$1;
+  readonly type: "str";
+}>;
+/**
+ * The attribute is set, with any type.
+ *
+ * @throws {InvalidAttributeNameError} If the name is outside the attribute name grammar.
+ * @throws {InvalidPredicateError} If given a system attribute — every entity has all of them, so
+ * the test would be a constant — or a `$` name that is not one.
+ *
+ * @example
+ * exists("reviewedBy")        // EXISTS(reviewedBy)
+ * not(exists("closedAt"))     // NOT EXISTS(closedAt)
+ */
+declare function exists<N$1 extends string>(name: N$1): ExistsNode<{
+  readonly name: N$1;
+  readonly type: never;
+}>;
+/**
+ * The attribute is set with exactly this type, whatever its value.
+ *
+ * Useful when the same name is written with different types across entities — a comparison already
+ * asserts the type, so this is for asking about the type alone.
+ *
+ * @param tag - The type tag: `bool`, `i32`, `u64`, `u256`, `dec`, `bytes32`, `str`, `addr` or
+ * `key` — any type but `bytes`, which is never indexed.
+ * @throws {InvalidAttributeNameError} If the name is outside the attribute name grammar.
+ * @throws {InvalidPredicateError} If the tag is not an indexable type, the name is a system
+ * attribute (whose type is fixed), or the name starts with `$` but is not a system attribute.
+ *
+ * @example
+ * hasType("age", "i32") // TYPEOF(age) = i32
+ */
+declare function hasType<N$1 extends string, T$1 extends IndexableTypeTag>(name: N$1, tag: T$1): TypeOfNode<{
+  readonly name: N$1;
+  readonly type: T$1;
+}>;
+/**
+ * The complement of an expression, evaluated against the set of live entities — unlike `!=`, it
+ * matches entities that never set the attribute at all.
+ *
+ * @example
+ * not(exists("closedAt"))            // NOT EXISTS(closedAt)
+ * not(and(eq("a", 1), eq("b", 2)))   // NOT (a = i32(1) AND b = i32(2))
+ */
+declare function not<R$1 extends AttributeRef>(expression: Expression<R$1>): NotNode<R$1>;
+/**
+ * All of these must hold.
+ *
+ * A single expression is returned unwrapped, so building a conjunction from a filtered list does
+ * not litter the query with redundant nesting.
+ *
+ * @param expressions - The expressions, as separate arguments or one array.
+ * @throws {InvalidPredicateError} If given nothing to combine.
+ *
+ * @example
+ * and(gte("level", i32(10)), eq("status", "open"))
+ * and(filters) // an array works too
+ */
+declare function and<const E extends readonly Expression[]>(expressions: E): Expression<RefsOf<E[number]>>;
+declare function and<const E extends readonly Expression[]>(...expressions: E): Expression<RefsOf<E[number]>>;
+/**
+ * At least one of these must hold.
+ *
+ * A single expression is returned unwrapped.
+ *
+ * @param expressions - The expressions, as separate arguments or one array.
+ * @throws {InvalidPredicateError} If given nothing to combine.
+ *
+ * @example
+ * or(eq("status", "open"), not(exists("closedAt")))
+ */
+declare function or<const E extends readonly Expression[]>(expressions: E): Expression<RefsOf<E[number]>>;
+declare function or<const E extends readonly Expression[]>(...expressions: E): Expression<RefsOf<E[number]>>;
+/**
+ * Checks every attribute an expression names against a schema — the runtime half of the check
+ * {@link SchemaRef} makes at compile time, for the callers the type system does not reach.
+ *
+ * @throws {InvalidPredicateError} If a predicate names something that is not a column of the
+ * schema, a column that is not indexed, or compares a column against a value of another type.
+ */
+declare function checkAgainstSchema(expression: Expression, schema: Schema): void;
+/**
+ * Renders an expression as the query string the node parses. Equivalent to `String(expression)`.
+ *
+ * Literals are always written tagged, even where the language would infer them: an untagged number
+ * defaults to `i32`, but spelling it `i32(10)` keeps the exact-type assertion visible in the query
+ * that actually went over the wire.
+ */
+declare function render(expression: Expression): string;
+//#endregion
+//#region src/types/entity.d.ts
+/**
+ * The fields an {@link Entity} can carry. Every one is optional: a query returns exactly the parts
+ * it selected, and `undefined` means "not asked for" rather than "empty".
+ */
+type EntityFields = {
+  key?: Hex | undefined;
+  owner?: Hex | undefined;
+  creator?: Hex | undefined;
+  /** Block the entity was created at. */
+  createdAt?: bigint | undefined;
+  /** Block the entity was last patched at. */
+  updatedAt?: bigint | undefined;
+  /** Block the entity expires at. */
+  expiresAt?: bigint | undefined;
+  /** The immutable properties the entity was created with. */
+  creationFlags?: ResolvedCreationFlags | undefined;
+  /** Attribute names, types and indexing, with no values. */
+  attributeSchema?: AttributeSchema | undefined;
+  /** Attribute names, types and values. */
+  attributes?: Attributes | undefined;
+};
+/**
+ * An entity as the node returns it, decoded: the fields a query selected, with its attributes as a
+ * map keyed by name. Which fields are populated is decided by the selection, so each may be
+ * `undefined`.
+ *
+ * Queries do not return these: `select()`, `query()` and `getEntity()` lay each one out as a flat
+ * row — the selected entity fields and attributes side by side, typed by the selection and, through
+ * a schema, by its columns.
+ */
+declare class Entity implements EntityFields {
+  key: Hex | undefined;
+  owner: Hex | undefined;
+  creator: Hex | undefined;
+  createdAt: bigint | undefined;
+  updatedAt: bigint | undefined;
+  expiresAt: bigint | undefined;
+  creationFlags: ResolvedCreationFlags | undefined;
+  attributeSchema: AttributeSchema | undefined;
+  attributes: Attributes | undefined;
+  constructor(fields?: EntityFields);
+}
+//#endregion
+//#region src/query/selection.d.ts
+/**
+ * The entity fields a row can carry. Each is `$`-prefixed, like the system attributes `where`
+ * filters on: an attribute name cannot start with `$`, so no attribute can collide with one.
+ */
+declare const SYSTEM_FIELDS: readonly ["$key", "$owner", "$creator", "$createdAt", "$updatedAt", "$expiresAt", "$creationFlags"];
+/** The name of an entity field a row carries alongside its attributes. */
+type SystemField = (typeof SYSTEM_FIELDS)[number];
+/** The {@link Entity} property a system field reads. */
+type EntityField<F extends SystemField> = F extends `$${infer N extends keyof EntityFields}` ? N : never;
+/**
+ * The keys a selection gives a fixed meaning: the entity fields, plus `$attributes` and
+ * `$attributeSchema`, which read an entity's attributes as a whole. Any key without a `$` names an
+ * attribute.
+ */
+type SelectionFields = { [K in SystemField]?: boolean } & {
+  /**
+   * Attribute names, types and indexing, without their values — a cheap way to find out what
+   * entities hold before fetching values that may be large. See {@link AttributeSchema}.
+   */
+  $attributeSchema?: boolean;
+  /** Every attribute, as a map keyed by name. */
+  $attributes?: boolean;
+};
+/** The selection keys with a fixed meaning, in the order they are written into the RPC `select`. */
+declare const SELECTION_KEYS: readonly ["$key", "$owner", "$creator", "$createdAt", "$updatedAt", "$expiresAt", "$creationFlags", "$attributeSchema", "$attributes"];
+/** A selection key with a fixed meaning. */
+type SelectionKey = (typeof SELECTION_KEYS)[number];
+/**
+ * A selection: entity fields, `$attributes` / `$attributeSchema`, and attributes by name, each set
+ * to `true` to ask for it. The same selection means the same thing with or without a schema —
+ * naming one with `.from(...)` only types and checks the selected attributes, and the filter. A
+ * named schema also restricts the query to entities tagged with its name, and leaves the tag out of
+ * every row.
+ */
+type Selection = Readonly<Record<string, boolean | undefined>>;
+/** Argument accepted by `select()` — a {@link Selection}, or `"*"` for everything. */
+type SelectArg = Selection | "*";
+/** Whether a selection value asks for the field: `true` does, `false` and `undefined` do not. */
+type Selected<V> = V extends false | undefined ? false : true;
+/**
+ * What a column reads back as: a value of its type, or `undefined` too if the column is optional.
+ */
+type ColumnValue<C> = C extends {
+  readonly type: infer T extends TypeTag;
+  readonly isOptional: infer O;
+} ? ValueOf<T> | (true extends O ? undefined : never) : never;
+/**
+ * What a selected key reads back as: an entity field as the entity has it, the attributes as a
+ * whole, or one attribute — typed by its column through a schema, and any value or none without.
+ */
+type FieldValue<K$1, TSchema extends Schema | undefined> = K$1 extends SystemField ? NonNullable<Entity[EntityField<K$1>]> : K$1 extends "$attributes" ? Attributes : K$1 extends "$attributeSchema" ? AttributeSchema : K$1 extends `$${string}` ? never : TSchema extends Schema ? K$1 extends keyof ColumnsOf<TSchema> ? ColumnValue<ColumnsOf<TSchema>[K$1]> : never : ArkivValue | undefined;
+/**
+ * One result of selection `S`, through schema `TSchema` or without one: the selected entity fields
+ * and attributes side by side, flat. Through a schema each attribute is typed as its column
+ * declares; without one it is whatever value the entity holds, or `undefined`. Accessing an
+ * unselected field is a compile error.
+ *
+ * @example
+ * // select({ $key: true, title: true })               → { $key: Hex; title: ArkivValue | undefined }
+ * // select({ $key: true, title: true }).from(Posts)   → { $key: Hex; title: StrValue }
+ */
+type Row<S, TSchema extends Schema | undefined = undefined> = { readonly [K in keyof S as Selected<S[K]> extends true ? K : never]: FieldValue<K, TSchema> };
+/**
+ * What `select()` / `select("*")` selects without a schema: every entity field and every
+ * attribute. Not the `$attributeSchema`: its point is learning an entity's shape without fetching
+ * its values, so returning it next to every value would only add to the response. It is only
+ * returned when asked for by name.
+ */
+type AllSelected = { [K in SystemField | "$attributes"]: true };
+/**
+ * The result when everything is selected without a schema — every entity field, and every
+ * attribute as the `$attributes` map. Also what `getEntity(key)` returns.
+ */
+type FullEntity = Row<AllSelected>;
+/** The row type when everything is selected through a schema — every entity field and column. */
+type FullRow<TSchema extends Schema> = Row<{ [K in SystemField | keyof ColumnsOf<TSchema>]: true }, TSchema>;
+declare const dynamic: unique symbol;
+/**
+ * The selection type of a builder whose selection is only known at runtime — `select(sel)` with
+ * `sel` typed {@link SelectArg} rather than written inline. Nothing about which fields will be
+ * present can be known statically, so results are typed with every field optional.
+ */
+type DynamicSelection = {
+  readonly [dynamic]: true;
+};
+/**
+ * A result whose selection is only known at runtime: any entity field and any attribute may be
+ * absent, because nothing says statically which were selected.
+ */
+type PartialRow<TSchema extends Schema | undefined = undefined> = { readonly [K in SystemField]?: NonNullable<Entity[EntityField<K>]> } & {
+  readonly $attributes?: Attributes;
+  readonly $attributeSchema?: AttributeSchema;
+} & (TSchema extends Schema ? { readonly [K in keyof ColumnsOf<TSchema>]?: ValueOf<ColumnsOf<TSchema>[K]["type"]> } : {
+  readonly [name: string]: ArkivValue | undefined;
+});
+/**
+ * Whether which fields `S` selects is only known at runtime: a selection typed {@link SelectArg} or
+ * {@link Selection}, or one with a field typed `boolean` rather than `true` or `false`.
+ */
+type IsDynamic<S> = string extends keyof Exclude<S, "*"> ? true : S extends "*" ? false : true extends { [K in keyof S]: [S[K]] extends [boolean] ? (boolean extends S[K] ? true : false) : false }[keyof S] ? true : false;
+/**
+ * The selection type a query carries for the selection `select()` or `query()` was given: `"*"`
+ * for everything, {@link DynamicSelection} when the fields are only known at runtime, and the
+ * selection itself otherwise.
+ */
+type SelectionOf<S> = [S] extends ["*"] ? "*" : IsDynamic<S> extends true ? DynamicSelection : S;
+/**
+ * Rejects a selection that asks for nothing at compile time — `{}`, or every field `false`:
+ * `unknown` when `S` asks for something, or when that is only known at runtime, and an object no
+ * selection satisfies otherwise.
+ */
+type NonEmptySelection<S> = SelectionOf<S> extends "*" | DynamicSelection ? unknown : [keyof { [K in keyof S as Selected<S[K]> extends true ? K : never]: true }] extends [never] ? {
+  "select() needs at least one field set to true": true;
+} : unknown;
+/**
+ * Rejects a `$` key that is not an entity field, `$attributes` or `$attributeSchema` at compile
+ * time. An attribute name cannot start with `$`, so such a key can only be a typo: `unknown` when
+ * there is none, and an object naming the offenders, which no selection satisfies, otherwise.
+ */
+type KnownSystemFields<S> = SelectionOf<S> extends "*" | DynamicSelection ? unknown : [Extract<Exclude<keyof S, SelectionKey>, `$${string}`>] extends [never] ? unknown : {
+  "selected names that are not entity fields": Extract<Exclude<keyof S, SelectionKey>, `$${string}`>;
+};
+/** What a query returns per result — a flat row, typed by the schema when there is one. */
+type ResultOf<TSelection, TSchema extends Schema | undefined> = TSelection extends DynamicSelection ? PartialRow<TSchema> : TSelection extends "*" ? TSchema extends Schema ? FullRow<TSchema> : FullEntity : Row<TSelection, TSchema>;
+/**
+ * The keys of a selection that mean nothing through `TSchema` — neither an entity field,
+ * `$attributes` / `$attributeSchema`, nor a column. None for a star or a selection only known at
+ * runtime, which `from()` checks when it runs instead.
+ */
+type UnknownSelection<TSelection, TSchema extends Schema> = TSelection extends "*" | DynamicSelection ? never : Exclude<keyof TSelection, SelectionKey | keyof ColumnsOf<TSchema>>;
+/**
+ * Converts a selection into the RPC `select` object — the same request {@link projectSelection}
+ * makes without a schema.
+ *
+ * Every field is opt-in — anything not explicitly selected is sent as `false`, including the key.
+ * Sending the full object rather than omitting the `false`s keeps what the SDK asked for legible in
+ * a request log, and pins the answer even if a node's defaults change.
+ *
+ * `undefined` or `"*"` selects everything.
+ *
+ * @throws If the selection asks for nothing, or names an attribute outside the name grammar.
+ *
+ * @example
+ * toRpcSelect()                                     // everything
+ * toRpcSelect({ $key: true })                       // only the key
+ * toRpcSelect({ $key: true, projectId: true })      // the key and one attribute
+ */
+declare function toRpcSelect(selection?: SelectArg): RpcSelect;
+/**
+ * A selection resolved, through a schema or without one: what to ask the node for, and how to lay
+ * the answer out.
+ */
+type Projection = {
+  readonly select: RpcSelect;
+  /** The entity fields each row carries. */
+  readonly fields: readonly SystemField[];
+  /**
+   * The attributes each row carries as fields of their own, by name — each with its column
+   * through a schema, which the value is checked against, and `undefined` without one.
+   */
+  readonly columns: readonly (readonly [name: string, column: AnyColumn | undefined])[];
+  /** Whether each row carries the `$attributes` map. */
+  readonly attributes: boolean;
+  /** Whether each row carries the `$attributeSchema`. */
+  readonly attributeSchema: boolean;
+  /** The tag each entity must carry, for a named schema. Checked, never part of the row. */
+  readonly tag: StrValue | undefined;
+};
+/**
+ * Resolves a selection, through a schema or without one. A key that does not start with `$` names
+ * an attribute — through a schema, it must be a column.
+ *
+ * `undefined` or `"*"` selects every entity field and, through a schema, every column; without one,
+ * every attribute as the `$attributes` map. The `$attributeSchema` is only selected by name.
+ *
+ * Attributes are fetched by name where possible, so the ones a row does not carry stay on the node.
+ * A named schema's tag is fetched too, so each entity can be checked against it.
+ *
+ * @throws If the selection asks for nothing, names a `$` key that is not an entity field, names an
+ * attribute outside the name grammar, or — through a schema — names an attribute that is not a
+ * column.
+ */
+declare function projectSelection(selection?: SelectArg, schema?: Schema): Projection;
+/**
+ * Lays an entity out as a row of `projection` — checking it against the schema, when there is one.
+ *
+ * @throws {SchemaMismatchError} If a named schema's entity is not tagged with its name, or the
+ * entity lacks a selected required column or holds one with a type other than the schema's — it
+ * was not written through this schema, or was patched since.
+ */
+declare function toRow(entity: Entity, projection: Projection): Record<string, unknown>;
+//#endregion
+//#region src/actions/public/query.d.ts
+type QueryOptions<TSelection extends SelectArg = SelectArg> = {
+  /** What to return — the same selection `select()` takes. Defaults to everything. */
+  select?: TSelection | undefined;
+  /** Block height to read at. Defaults to the head. */
+  atBlock?: bigint | undefined;
+  /** Page size, up to the node maximum of 100. */
+  limit?: number | undefined;
+  /** Cursor from a previous page. */
+  cursor?: string | undefined;
+  /** Whether to also count every entity the query matches, returned as `count`. */
+  count?: boolean | undefined;
+};
+/**
+ * What one result of a `query()` reads as for selection `S`: the same row `select(S)` returns
+ * without a schema — every field when everything is selected, and every field optional when the
+ * selection is only known at runtime.
+ */
+type QueryRow<S> = ResultOf<SelectionOf<S>, undefined>;
+type QueryReturnType<TResult = FullEntity> = {
+  entities: TResult[];
+  /** The cursor for the next page, or `undefined` when no pages remain. */
+  cursor: string | undefined;
+  /** The block the page was read at. */
+  blockNumber: bigint;
+  /** How many entities the query matches, if `count` was set. */
+  count: bigint | undefined;
+};
+//#endregion
+//#region src/types/events.d.ts
+/**
+ * Where an event sits in the chain — carried by every on-chain entity event.
+ *
+ * Operations apply in batch order and emit one event each, so `blockNumber` and `logIndex` together
+ * are the order the operations were applied in. A replica that replays them in that order sees
+ * exactly what the engine did.
+ */
+type EntityEventContext = {
+  /** The block the operation was applied in. */
+  blockNumber: bigint;
+  /** The transaction the operation was part of. */
+  transactionHash: Hex;
+  /** The event's position within its block. */
+  logIndex: number;
+};
+/** An entity was created. */
+type EntityCreatedEvent = EntityEventContext & {
+  type: "EntityCreated";
+  entityKey: Hex;
+  owner: Address;
+  /** The block the entity is set to expire at. */
+  expiresAt: bigint;
+  /**
+   * The immutable properties the entity was created with, decoded from its `creationFlags` byte.
+   */
+  creationFlags: ResolvedCreationFlags;
+};
+/**
+ * An entity's attributes changed.
+ *
+ * The event says *that* it changed, not what to — read the entity to see the new state.
+ */
+type EntityPatchedEvent = EntityEventContext & {
+  type: "EntityPatched";
+  entityKey: Hex;
+  owner: Address;
+};
+/** An entity's expiry moved further out. */
+type ExpiryExtendedEvent = EntityEventContext & {
+  type: "ExpiryExtended";
+  entityKey: Hex;
+  /**
+   * The entity's owner — **not** whoever extended it. An entity created with
+   * `permissionlessExtension` can be extended by anyone, and the event does not say by whom; read
+   * the transaction's sender if you need that.
+   */
+  owner: Address;
+  /** The block the entity is now set to expire at. */
+  expiresAt: bigint;
+};
+/** An entity changed hands. */
+type OwnershipTransferredEvent = EntityEventContext & {
+  type: "OwnershipTransferred";
+  entityKey: Hex;
+  previousOwner: Address;
+  newOwner: Address;
+};
+/** An entity was deleted by its owner, before its expiry. */
+type EntityDeletedEvent = EntityEventContext & {
+  type: "EntityDeleted";
+  entityKey: Hex;
+  owner: Address;
+};
+/**
+ * Every event the engine emits, discriminated by `type`.
+ */
+type EntityEvent = EntityCreatedEvent | EntityPatchedEvent | ExpiryExtendedEvent | OwnershipTransferredEvent | EntityDeletedEvent;
+//#endregion
+//#region src/actions/public/watchEntityEvents.d.ts
+/**
+ * Handlers and options for `client.watchEntityEvents`. Every handler is optional; the watcher does
+ * the work for the ones you pass.
+ */
+type WatchEntityEventsParameters = {
+  onEntityCreated?: ((event: EntityCreatedEvent) => void) | undefined;
+  onEntityPatched?: ((event: EntityPatchedEvent) => void) | undefined;
+  onExpiryExtended?: ((event: ExpiryExtendedEvent) => void) | undefined;
+  onOwnershipTransferred?: ((event: OwnershipTransferredEvent) => void) | undefined;
+  onEntityDeleted?: ((event: EntityDeletedEvent) => void) | undefined;
+  /**
+   * Every event, in application order, whatever its type. Runs *before* the per-event handler for
+   * the same event.
+   *
+   * This is the replay seam: operations apply in batch order and emit one event each, so an
+   * off-chain replica that consumes this in order sees exactly what the engine did.
+   */
+  onEvent?: ((event: EntityEvent) => void) | undefined;
+  /**
+   * Transport failures, logs that will not decode, and anything one of your own handlers throws.
+   *
+   * Defaults to `console.error`. A watcher whose filter the node dropped otherwise just goes quiet,
+   * and a quiet watcher is indistinguishable from a quiet chain.
+   */
+  onError?: ((error: Error) => void) | undefined;
+  /** Replay from this block before following the head. Defaults to the head. */
+  fromBlock?: bigint | undefined;
+  /** How often to poll, in milliseconds. Defaults to half a block. */
+  pollingInterval?: number | undefined;
+};
+//#endregion
+//#region src/actions/wallet/createEntity.d.ts
+/**
+ * How an created entity lives: its lifetime, plus the flags and salt it is created with.
+ *
+ * @example
+ * { expiration: ExpirationTime.fromDays(30) }
+ *
+ * @example Pin an absolute deadline, but never let it leave the entity with less than a day:
+ * {
+ *   expiration: ExpirationTime.atDate(someDeadline, {
+ *     atLeast: ExpirationTime.fromDays(1),    // ...but live at least a day regardless
+ *   }),
+ *   flags: { readonly: true },
+ * }
+ */
+type CreateEntityOptions = {
+  /**
+   * How long the entity should live, built with {@link ExpirationTime}.
+   *
+   * `ExpirationTime.fromDays(30)` is the everyday form. `atBlock` / `atDate` pin an absolute
+   * deadline instead, and either can carry `{ atLeast }` to guarantee a minimum life on top of it.
+   */
+  expiration: Expiry;
+  /**
+   * Properties fixed at creation: `readonly` and `permissionlessExtension`. No operation changes
+   * them afterwards, so an entity is whatever it was created as for life. Both default to `false`.
+   */
+  flags?: CreationFlags | undefined;
+  /**
+   * The salt mixed into the entity key. Defaults to 128 random bits, which makes the key
+   * unpredictable to everyone but the creator.
+   *
+   * Pass {@link NO_SALT} for a key derived from the owner and nonce alone — predictable by anyone,
+   * which is what you want only when a third party must be able to compute the key in advance.
+   */
+  salt?: SaltInput | undefined;
+};
+/**
+ * One entity to create, as a batch carries it: the schema, the values, and the {@link CreateEntityOptions}.
+ *
+ * @typeParam S - The schema the values are typed by.
+ */
+type CreateEntityParameters<S extends Schema = Schema> = CreateEntityOptions & {
+  /** The schema the entity is written through. */
+  schema: S;
+  /**
+   * The entity's values, keyed by column. Every required column must be given; an optional one may
+   * be left out, and a defaulted one left out is written with its default.
+   */
+  values: CreateEntityValues<S>;
+};
+/**
+ * The result of creating an entity.
+ */
+type CreateEntityReturnType = {
+  /** The new entity's key. */
+  entityKey: Hex;
+  txHash: Hash;
+  /**
+   * The block the entity expires at, as the engine recorded it — read from the `EntityCreated`
+   * event, so a duration is already resolved against the block the transaction landed in.
+   */
+  expiresAt: bigint;
+};
+//#endregion
+//#region src/actions/wallet/deleteEntity.d.ts
+/**
+ * Parameters for the deleteEntity function.
+ * - entityKey: The key of the entity to delete.
+ */
+type DeleteEntityParameters = {
+  entityKey: Hex;
+};
+/**
+ * Return type for the deleteEntity function.
+ * - entityKey: The key of the entity.
+ * - txHash: The transaction hash.
+ */
+type DeleteEntityReturnType = {
+  entityKey: Hex;
+  txHash: Hash;
+};
+//#endregion
+//#region src/actions/wallet/extendEntity.d.ts
+/**
+ * Parameters for extending an entity's life.
+ *
+ * An extension **sets a new expiry**; it does not add to the existing one. It is resolved exactly
+ * as a create's is — a duration counts from now, not from the entity's current expiry — so
+ * `ExpirationTime.fromDays(30)` means "alive for thirty more days from now" whatever the entity's
+ * remaining life happened to be.
+ *
+ * The engine rejects an extension that would move the expiry earlier, so extending an entity by
+ * less than it already has left is an error rather than a silent shortening. One that resolves to
+ * the current expiry changes nothing.
+ *
+ * @example
+ * await client.extendEntity({ entityKey, expiration: ExpirationTime.fromDays(30) })
+ * await client.extendEntity({ entityKey, expiration: ExpirationTime.atBlock(1_200_000n) })
+ */
+type ExtendEntityParameters = {
+  entityKey: Hex;
+  /** The entity's new lifetime, built with {@link ExpirationTime}. */
+  expiration: Expiry;
+};
+/**
+ * The result of extending an entity.
+ */
+type ExtendEntityReturnType = {
+  entityKey: Hex;
+  txHash: Hash;
+  /**
+   * The block the entity now expires at, as the engine recorded it — read from the
+   * `ExpiryExtended` event, so a duration is already resolved against the block the transaction
+   * landed in.
+   */
+  expiresAt: bigint;
+};
+//#endregion
+//#region src/actions/wallet/patchEntity.d.ts
+/**
+ * What a patch changes.
+ *
+ * A patch names only what changes. Columns it does not mention keep whatever value they have — so
+ * a caller can change one column without first reading the entity to learn what the others are,
+ * and without racing anyone else who is changing a different one.
+ *
+ * @typeParam S - The schema the changes are typed by.
+ *
+ * @example
+ * { set: { title: "Cells, not entities", score: dec("4.2") }, unset: ["thumbnail"] }
+ */
+type PatchEntityChanges<S extends Schema = Schema> = {
+  /**
+   * Columns to write, keyed by name. Each is written with the indexed flag its column declares,
+   * so writing a column whose indexing the schema has since changed changes it on the entity too.
+   * Defaults do not apply: a patch writes only what it names.
+   *
+   * @throws {SchemaMismatchError} If a name is not a column, or a value is not of its column's type.
+   */
+  set?: PatchEntityValues<S> | undefined;
+  /**
+   * Optional columns to remove. Naming one the entity does not carry is not an error — the outcome
+   * is the same either way, and a caller clearing a column should not have to know whether it was
+   * ever set.
+   *
+   * @throws {ConflictingMutationError} If a name also appears in `set`.
+   */
+  unset?: readonly OptionalColumnName<S>[] | undefined;
+};
+/**
+ * One patch, as a batch carries it: the schema, the entity, and the {@link PatchEntityChanges}.
+ *
+ * The entity's identity is fixed: a patch never moves the key, the owner, the creation flags or the
+ * expiry. Use `extendEntity` for the expiry and `changeOwnership` for the owner.
+ */
+type PatchEntityParameters<S extends Schema = Schema> = PatchEntityChanges<S> & {
+  /** The schema the changes are typed by. */
+  schema: S;
+  /** The entity to patch. */
+  entityKey: Hex;
+};
+/** The result of a patch. */
+type PatchEntityReturnType = {
+  /** The patched entity's key — unchanged, since a patch never moves it. */
+  entityKey: Hex;
+  txHash: Hash;
+};
+//#endregion
+//#region src/actions/wallet/executeBatch.d.ts
+/**
+ * Parameters for the executeBatch function.
+ *
+ * At least one operation is required; a batch with nothing in it throws rather than spending gas on
+ * an empty transaction.
+ *
+ * Each create and patch names its own schema, and is typed by it — a batch can write entities of
+ * several schemas at once.
+ *
+ * @typeParam TCreates - The schema of each create, in order. Inferred.
+ * @typeParam TPatches - The schema of each patch, in order. Inferred.
+ */
+type ExecuteBatchParameters<TCreates extends readonly Schema[] = readonly Schema[], TPatches extends readonly Schema[] = readonly Schema[]> = {
+  /** The entities to create. */
+  creates?: { readonly [I in keyof TCreates]: CreateEntityParameters<TCreates[I]> } | undefined;
+  /** The patches to apply. */
+  patches?: { readonly [I in keyof TPatches]: PatchEntityParameters<TPatches[I]> } | undefined;
+  /** The entities to delete. */
+  deletes?: readonly DeleteEntityParameters[] | undefined;
+  /** The expiries to set. */
+  extensions?: readonly ExtendEntityParameters[] | undefined;
+  /** The ownership transfers to perform. */
+  ownershipChanges?: readonly ChangeOwnershipParameters[] | undefined;
+};
+/** Return type for the executeBatch function. */
+type ExecuteBatchReturnType = {
+  /** The transaction hash. */
+  txHash: Hash;
+  /** The keys of the created entities, in batch order. */
+  createdEntities: Hex[];
+  /** The keys of the patched entities. */
+  patchedEntities: Hex[];
+  /** The keys of the deleted entities. */
+  deletedEntities: Hex[];
+  /** The keys of the extended entities. */
+  extendedEntities: Hex[];
+  /** The keys of the entities handed to a new owner. */
+  ownershipChanges: Hex[];
+};
+//#endregion
+//#region src/types/txParams.d.ts
+/**
+ * Transaction fields a write action passes through to the wallet, for the cases where the defaults
+ * are not what you want.
+ *
+ * Fee style is either/or: give `gasPrice` for a legacy transaction, or `maxFeePerGas` /
+ * `maxPriorityFeePerGas` for an EIP-1559 one. Mixing the two does not typecheck. Anything left out
+ * is estimated.
+ */
+type TxParams = {
+  gas?: bigint;
+  nonce?: number;
+  gasPrice?: bigint;
+  maxFeePerGas?: never;
+  maxPriorityFeePerGas?: never;
+} | {
+  gas?: bigint;
+  nonce?: number;
+  maxFeePerGas?: bigint;
+  maxPriorityFeePerGas?: bigint;
+  gasPrice?: never;
+};
+//#endregion
+//#region src/actions/wallet/changeOwnership.d.ts
+/**
+ * Parameters for the changeOwnership function.
+ * - entityKey: The key of the entity.
+ * - newOwner: The address of the new owner.
+ */
+type ChangeOwnershipParameters = {
+  entityKey: Hex;
+  newOwner: Hex;
+};
+/**
+ * Return type for the changeOwnership function.
+ * - entityKey: The key of the entity.
+ * - txHash: The transaction hash.
+ */
+type ChangeOwnershipReturnType = {
+  entityKey: Hex;
+  txHash: Hash;
+};
+//#endregion
+export { ComparisonNode as $, FullRow as A, ArkivClient as At, Selection as B, OwnershipTransferredEvent as C, or as Ct, ColumnValue as D, PredictEntityKeysReturnType as Dt, QueryRow as E, PredictEntityKeysParameters as Et, ResultOf as F, RpcEntity as Ft, projectSelection as G, SelectionOf as H, Row as I, RpcQueryOptions as It, Entity as J, toRow as K, SYSTEM_FIELDS as L, RpcSelect as Lt, NonEmptySelection as M, RpcAttribute as Mt, PartialRow as N, RpcAttributeSchemaEntry as Nt, DynamicSelection as O, PredictedEntityKey as Ot, Projection as P, RpcCreationFlags as Pt, BetweenNode as Q, SelectArg as R, ExpiryExtendedEvent as S, not as St, QueryReturnType as T, startsWith as Tt, SystemField as U, SelectionFields as V, UnknownSelection as W, AndNode as X, EntityFields as Y, AttributeRef as Z, EntityCreatedEvent as _, gte as _t, ExecuteBatchReturnType as a, PredicateValue as at, EntityEventContext as b, lte as bt, PatchEntityReturnType as c, StartsWithNode as ct, DeleteEntityParameters as d, and as dt, ComparisonOperator as et, DeleteEntityReturnType as f, between as ft, WatchEntityEventsParameters as g, gt, CreateEntityReturnType as h, exists as ht, ExecuteBatchParameters as i, OrNode as it, KnownSystemFields as j, ArkivRpcSchema as jt, FullEntity as k, GetBlockTimingReturnType as kt, ExtendEntityParameters as l, SystemAttributeRef as lt, CreateEntityParameters as m, eq as mt, ChangeOwnershipReturnType as n, Expression as nt, PatchEntityChanges as o, RefsOf as ot, CreateEntityOptions as p, checkAgainstSchema as pt, toRpcSelect as q, TxParams as r, NotNode as rt, PatchEntityParameters as s, SchemaRef as st, ChangeOwnershipParameters as t, ExistsNode as tt, ExtendEntityReturnType as u, TypeOfNode as ut, EntityDeletedEvent as v, hasType as vt, QueryOptions as w, render as wt, EntityPatchedEvent as x, ne as xt, EntityEvent as y, lt as yt, Selected as z };
+//# sourceMappingURL=changeOwnership-gXf-lBqI.d.ts.map