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

package/dist/index-DaNeJUw8.d.ts

@@ -1,955 +0,0 @@
-import { C as ValueInput, G as StrValue, R as ArkivValue, Y as UserTypeTag, h as Attributes, m as AttributeSchema, p as AttributeInputs } from "./index-Cd2aaWme.js";
-import { a as SaltInput, c as CreationFlags, l as ResolvedCreationFlags } from "./index-BkqSnGJH.js";
-import { n as Expiry } from "./expiry-BxOlvVWC.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, 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 and its type, with no value. */
-type RpcAttributeSchemaEntry = {
-  name: string;
-  type: string;
-};
-/**
- * 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;
-  contentType?: string;
-  payload?: Hex;
-  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;
-  contentType?: boolean;
-  payload?: boolean;
-  attributeSchema?: boolean;
-  attributes?: boolean | Record<string, 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 200. */
-  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;
-  };
-}, {
-  Method: "arkiv_getBlockTiming";
-  Parameters?: [];
-  ReturnType: {
-    current_block: bigint;
-    current_block_time: number;
-    duration: number;
-  };
-}, {
-  Method: "arkiv_getEntityCount";
-  Parameters?: [];
-  ReturnType: 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, TLength extends number, TAcc extends T[] = []> = number extends TLength ? T[] : TAcc["length"] extends TLength ? TAcc : Repeat<T, TLength, [...TAcc, T]>;
-/**
- * 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 { key } from "@arkiv-network/sdk/attr"
- *
- * const [parent, child] = await client.predictEntityKeys({ owner: account.address, count: 2 })
- * await client.executeBatch({
- *   creates: [
- *     { payload, contentType, expires, salt: parent.salt },
- *     {
- *       payload,
- *       contentType,
- *       expires,
- *       salt: child.salt,
- *       attributes: { parent: key(parent.key) },
- *     },
- *   ],
- * })
- */
-//#endregion
-//#region src/query/expression.d.ts
-/**
- * The comparison operators the query language defines. `<` `<=` `>` `>=` need an ordered type —
- * `i32`, `u64`, `u256` or `dec`; every type accepts `=` and `!=`.
- */
-type ComparisonOperator = "=" | "!=" | "<" | "<=" | ">" | ">=";
-/** A comparison between an attribute and a typed literal. */
-type ComparisonNode = {
-  readonly kind: "comparison";
-  readonly name: string;
-  readonly operator: ComparisonOperator;
-  readonly value: ArkivValue;
-};
-/** A `STARTSWITH` prefix test, the language's only pattern operator. */
-type StartsWithNode = {
-  readonly kind: "startsWith";
-  readonly name: string;
-  readonly value: StrValue;
-};
-/** An `EXISTS(name)` test — true when the attribute is set with any type. */
-type ExistsNode = {
-  readonly kind: "exists";
-  readonly name: string;
-};
-/** A `TYPEOF(name) = tag` test. */
-type TypeOfNode = {
-  readonly kind: "typeOf";
-  readonly name: string;
-  readonly tag: UserTypeTag;
-};
-/** The complement of an expression, evaluated against the active-entity set. */
-type NotNode = {
-  readonly kind: "not";
-  readonly expression: Expression;
-};
-/** A conjunction. */
-type AndNode = {
-  readonly kind: "and";
-  readonly expressions: readonly Expression[];
-};
-/** A disjunction. */
-type OrNode = {
-  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.
- *
- * @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 = ComparisonNode | StartsWithNode | ExistsNode | TypeOfNode | NotNode | AndNode | OrNode;
-/**
- * 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 {InvalidPredicateError} If the name is not a queryable attribute, or a system attribute
- * is compared against the wrong type.
- *
- * @example
- * eq("status", str("open"))     // status = str('open')
- * eq("flagged", true)           // flagged = true
- * eq("$owner", addr(account))   // $owner = addr(0xd8dA…)
- */
-declare function eq(name: string, value: ValueInput): ComparisonNode;
-/**
- * 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.
- *
- * @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(name: string, value: ValueInput): ComparisonNode;
-/**
- * Attribute is greater than value. Ordered types only (`i32`, `u64`, `u256`, `dec`).
- *
- * @throws {UnsupportedOperatorError} If the value's type carries no ordered index.
- *
- * @example
- * gt("level", i32(10))              // level > i32(10)
- * gt("$expiresAt", u64(1_200_000n)) // $expiresAt > u64(1200000)
- */
-declare function gt(name: string, value: ValueInput): ComparisonNode;
-/**
- * Attribute is greater than or equal to value. Ordered types only (`i32`, `u64`, `u256`, `dec`).
- *
- * @throws {UnsupportedOperatorError} If the value's type carries no ordered index.
- *
- * @example
- * gte("score", dec("3.5")) // score >= dec(3.5)
- */
-declare function gte(name: string, value: ValueInput): ComparisonNode;
-/**
- * Attribute is less than value. Ordered types only (`i32`, `u64`, `u256`, `dec`).
- *
- * @throws {UnsupportedOperatorError} If the value's type carries no ordered index.
- *
- * @example
- * lt("level", i32(10)) // level < i32(10)
- */
-declare function lt(name: string, value: ValueInput): ComparisonNode;
-/**
- * Attribute is less than or equal to value. Ordered types only (`i32`, `u64`, `u256`, `dec`).
- *
- * @throws {UnsupportedOperatorError} If the value's type carries no ordered index.
- *
- * @example
- * lte("score", dec("5")) // score <= dec(5)
- */
-declare function lte(name: string, value: ValueInput): ComparisonNode;
-/**
- * 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 {InvalidPredicateError} If the name is not a queryable 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(name: string, prefix: string | StrValue): StartsWithNode;
-/**
- * The attribute is set, with any type.
- *
- * @throws {InvalidPredicateError} If given a system attribute — every entity has all of them, so
- * the test would be a constant.
- *
- * @example
- * exists("reviewedBy")        // EXISTS(reviewedBy)
- * not(exists("closedAt"))     // NOT EXISTS(closedAt)
- */
-declare function exists(name: string): ExistsNode;
-/**
- * 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`.
- * @throws {InvalidPredicateError} If the tag is not a settable type, or the name is a system
- * attribute (whose type is fixed).
- *
- * @example
- * hasType("age", "i32") // TYPEOF(age) = i32
- */
-declare function hasType(name: string, tag: UserTypeTag): TypeOfNode;
-/**
- * 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(expression: Expression): NotNode;
-/**
- * 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(expressions: readonly Expression[]): Expression;
-declare function and(...expressions: Expression[]): Expression;
-/**
- * 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(expressions: readonly Expression[]): Expression;
-declare function or(...expressions: Expression[]): Expression;
-/**
- * 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;
-  contentType?: string | undefined;
-  payload?: Uint8Array | undefined;
-  /** Attribute names and types, with no values. */
-  attributeSchema?: AttributeSchema | undefined;
-  /** Attribute names, types and values. */
-  attributes?: Attributes | undefined;
-};
-/**
- * An entity as it comes back from a query.
- *
- * Which fields are populated is decided by the query's selection — `select({ key: true })` gives
- * back an entity carrying only its key. The static type of a `select()` result is narrowed to
- * exactly the selected fields, so in typed code the `undefined`s here are not reachable.
- */
-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;
-  contentType: string | undefined;
-  payload: Uint8Array | undefined;
-  attributeSchema: AttributeSchema | undefined;
-  attributes: Attributes | undefined;
-  constructor(fields?: EntityFields);
-  /**
-   * The payload decoded as UTF-8 text.
-   *
-   * @throws If the payload was not selected, or is not valid UTF-8.
-   */
-  toText(): string;
-  /**
-   * The payload parsed as JSON.
-   *
-   * @throws If the payload was not selected, is empty, or is not valid JSON.
-   */
-  toJson(): any;
-}
-//#endregion
-//#region src/query/selection.d.ts
-/**
- * The entity fields a query can select. Each maps one-to-one onto a field of {@link Entity}.
- *
- * `attributes` takes a third form beyond `true`/`false`: a map of names, to fetch only those.
- */
-type SelectionFields = {
-  key?: boolean;
-  owner?: boolean;
-  creator?: boolean;
-  createdAt?: boolean;
-  updatedAt?: boolean;
-  expiresAt?: boolean;
-  creationFlags?: boolean;
-  contentType?: boolean;
-  payload?: boolean;
-  /** Attribute names and types, without their values. */
-  attributeSchema?: boolean;
-  /** `true` for every attribute, or a map of names for a subset. */
-  attributes?: boolean | Readonly<Record<string, boolean>>;
-};
-/** The selection keys, in the order they are written into the RPC `select` object. */
-declare const SELECTION_KEYS: readonly ["key", "owner", "creator", "createdAt", "updatedAt", "expiresAt", "creationFlags", "contentType", "payload", "attributeSchema", "attributes"];
-/**
- * Requires at least one property of `T` to be present.
- * `{}` is not assignable, which is how `select({})` is rejected at compile time.
- */
-type AtLeastOne<T, K$1 extends keyof T = keyof T> = { [P in K$1]: Required<Pick<T, P>> & Partial<Omit<T, P>> }[K$1];
-/**
- * A non-empty entity selection — the object form accepted by `select()`. At least one field must be
- * selected.
- */
-type EntitySelection = AtLeastOne<SelectionFields>;
-/** Argument accepted by `select()` — a non-empty {@link EntitySelection}, or `"*"` for everything. */
-type SelectArg = EntitySelection | "*";
-/** Whether a selection value asks for the field: `true`, or a non-empty map of attribute names. */
-type Selected<V> = V extends false | undefined ? false : true;
-/**
- * The result of a selection `S`: an {@link Entity} narrowed to exactly the selected fields (each
- * non-`undefined`). The shape is flat — `select({ owner: true })` yields `{ owner: Hex }`, read as
- * `entity.owner`. Accessing an unselected field is a compile error.
- *
- * `toText()` / `toJson()` operate on the payload, so they appear only when `payload` was selected —
- * calling them otherwise would always throw.
- */
-type ProjectedEntity<S> = { readonly [K in keyof S as Selected<S[K]> extends true ? K : never]: K extends keyof Entity ? NonNullable<Entity[K]> : never } & (S extends {
-  payload: true;
-} ? Pick<Entity, "toText" | "toJson"> : unknown);
-/** A selection of every field, used to type the result of `select()` / `select("*")`. */
-type AllSelected = { [K in (typeof SELECTION_KEYS)[number]]: true };
-/** The projected entity type when everything is selected — every field, plus the methods. */
-type FullEntity = ProjectedEntity<AllSelected>;
-/**
- * Converts a {@link SelectArg} into the RPC `select` object.
- *
- * 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.
- *
- * @example
- * toRpcSelect()                    // everything
- * toRpcSelect({ key: true })       // only the key
- * toRpcSelect({ attributes: { projectId: true } })  // one named attribute
- */
-declare function toRpcSelect(selection?: SelectArg): RpcSelect;
-//#endregion
-//#region src/actions/public/query.d.ts
-type QueryOptions = {
-  /** What to return. Defaults to everything. */
-  select?: SelectArg | undefined;
-  /** Block height to read at. Defaults to the head. */
-  atBlock?: bigint | undefined;
-  /** Page size, up to the node maximum of 200. */
-  limit?: number | undefined;
-  /** Cursor from a previous page. */
-  cursor?: string | undefined;
-};
-type QueryReturnType = {
-  entities: Entity[];
-  /** The cursor for the next page, or `undefined` when no pages remain. */
-  cursor: string | undefined;
-  /** The block the page was read at. */
-  blockNumber: bigint;
-};
-//#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 or payload 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/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
-//#region src/actions/wallet/createEntity.d.ts
-/**
- * Parameters for creating an entity.
- *
- * An entity always carries contents and a type for them, plus a lifetime. Attributes, flags and a
- * salt are optional on top of that.
- *
- * @example
- * const { entityKey } = await client.createEntity({
- *   attributes: {
- *     level:   i32(10),
- *     balance: u256(1_000_000n),
- *     score:   dec("3.5"),
- *     name:    "Bob",   // bare string -> str
- *     flagged: true,    // bare boolean -> bool
- *   },
- *   payload: jsonToPayload({ hello: "world" }),
- *   contentType: "application/json",
- *   expires: ExpirationTime.fromDays(30),
- *   flags: { readonly: true },
- * })
- *
- * @example Pin an absolute deadline, but refuse to create something nearly dead:
- * await client.createEntity({
- *   payload, contentType: "application/json",
- *   expires: ExpirationTime.atDate(someDeadline, {
- *     atLeast: ExpirationTime.fromDays(1),    // ...but live at least a day regardless
- *   }),
- * })
- *
- * @example An entity that is nothing but queryable attributes still declares its (empty) contents:
- * await client.createEntity({
- *   attributes: { parent: key(parentKey), rank: i32(3) },
- *   payload: new Uint8Array(),
- *   contentType: "application/octet-stream",
- *   expires: ExpirationTime.fromDays(30),
- * })
- */
-type CreateEntityParameters = {
-  /**
-   * 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.
-   */
-  expires: Expiry;
-  /**
-   * The entity's opaque payload. Travels to the engine as the `$payload` system attribute; on this
-   * surface it is just the entity's contents.
-   *
-   * Pass an empty `Uint8Array` for an entity that is nothing but queryable attributes — it is
-   * written as an empty payload rather than left unset, so what you pass is what is stored.
-   */
-  payload: Uint8Array;
-  /** The payload's MIME type, e.g. `"application/json"`. Sent as the `$contentType` cell. */
-  contentType: MimeType | (string & {});
-  /**
-   * The entity's queryable attributes, keyed by name. Values are the tagged constructors from
-   * `@arkiv-network/sdk/attr` — `i32`, `u64`, `u256`, `dec`, `str`, `addr`, `key`, `bytes32`,
-   * `bool` — or a bare `boolean`, `number`, `bigint` or `string` where the type is unambiguous.
-   *
-   * @throws {InvalidAttributeNameError} If a name violates the attribute-name grammar.
-   * @throws {InvalidValueError} If a value does not fit the type it names or defaults to.
-   */
-  attributes?: AttributeInputs | undefined;
-  /**
-   * 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;
-};
-/**
- * The result of creating an entity.
- */
-type CreateEntityReturnType = {
-  /** The new entity's key. */
-  entityKey: Hex;
-  txHash: Hash;
-  /**
-   * The block the entity is expected to expire at, resolved against the block the transaction was
-   * built on.
-   *
-   * The engine resolves a duration against the block the transaction actually lands in, so for
-   * `ExpirationTime.fromDays(30)` and friends this is a lower bound: the real expiry is later by
-   * however many blocks passed between building and inclusion. An `atBlock` deadline is exact.
-   */
-  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 not move the expiry later, so extending an entity by
- * less than it already has left is an error rather than a silent shortening.
- *
- * @example
- * await client.extendEntity({ entityKey, expires: ExpirationTime.fromDays(30) })
- * await client.extendEntity({ entityKey, expires: ExpirationTime.atBlock(1_200_000n) })
- */
-type ExtendEntityParameters = {
-  entityKey: Hex;
-  /** The entity's new lifetime, built with {@link ExpirationTime}. */
-  expires: Expiry;
-};
-/**
- * The result of extending an entity.
- */
-type ExtendEntityReturnType = {
-  entityKey: Hex;
-  txHash: Hash;
-  /**
-   * The block the entity is now expected to expire at, resolved against the block the transaction
-   * was built on. Durations are approximate, so treat this as the estimate the operation was built
-   * from rather than the block the engine settled on.
-   */
-  expiresAt: bigint;
-};
-//#endregion
-//#region src/actions/wallet/patchEntity.d.ts
-/**
- * Parameters for patching an entity.
- *
- * A patch names only what changes. Attributes it does not mention keep whatever value they have, and
- * the payload and content type stay as they are unless given — so a caller can change one field
- * without first reading the entity to learn what the others are, and without racing anyone else who
- * is changing a different field.
- *
- * 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.
- *
- * @example Change one attribute and remove another, leaving the payload alone:
- * await client.patchEntity({
- *   entityKey,
- *   set: { status: "published", level: i32(11) },
- *   unset: ["draft"],
- * })
- *
- * @example Replace the contents without touching a single attribute:
- * await client.patchEntity({
- *   entityKey,
- *   payload: jsonToPayload({ hello: "again" }),
- * })
- */
-type PatchEntityParameters = {
-  /** The entity to patch. */
-  entityKey: Hex;
-  /**
-   * Attributes to write, keyed by name. An existing attribute is overwritten — including with a
-   * different type — and a name the entity does not carry yet is added.
-   *
-   * Values are the tagged constructors from `@arkiv-network/sdk/attr` — `i32`, `u64`, `u256`,
-   * `dec`, `str`, `addr`, `key`, `bytes32`, `bool` — or a bare `boolean`, `number`, `bigint` or
-   * `string` where the type is unambiguous.
-   *
-   * @throws {InvalidAttributeNameError} If a name violates the attribute-name grammar.
-   * @throws {InvalidValueError} If a value does not fit the type it names or defaults to.
-   */
-  set?: AttributeInputs | undefined;
-  /**
-   * Attribute names 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 field should not have to know whether it was
-   * ever set.
-   *
-   * @throws {ConflictingMutationError} If a name also appears in `set`.
-   */
-  unset?: readonly string[] | undefined;
-  /**
-   * The entity's new payload. Omit it to leave the current contents untouched; pass an empty
-   * `Uint8Array` to replace them with nothing.
-   */
-  payload?: Uint8Array | undefined;
-  /**
-   * The payload's new MIME type. Omit it to keep the current one — which is what you want when the
-   * new payload is the same kind of thing as the old.
-   */
-  contentType?: MimeType | (string & {}) | undefined;
-};
-/** The result of patching an entity. */
-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.
- */
-type ExecuteBatchParameters = {
-  /** The entities to create. */
-  creates?: CreateEntityParameters[];
-  /** The patches to apply. */
-  patches?: PatchEntityParameters[];
-  /** The entities to delete. */
-  deletes?: DeleteEntityParameters[];
-  /** The expiries to set. */
-  extensions?: ExtendEntityParameters[];
-  /** The ownership transfers to perform. */
-  ownershipChanges?: ChangeOwnershipParameters[];
-};
-/** 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/mimeTypes.d.ts
-type MimeType = "text/plain" | "text/html" | "text/css" | "text/csv" | "text/xml" | "text/javascript" | "application/json" | "application/xml" | "application/pdf" | "application/zip" | "application/gzip" | "application/octet-stream" | "application/javascript" | "application/x-www-form-urlencoded" | "image/png" | "image/jpeg" | "image/webp" | "image/gif" | "image/svg+xml" | "audio/mpeg" | "audio/wav" | "audio/ogg" | "video/mp4" | "video/webm" | "video/ogg" | "multipart/form-data";
-//#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
-export { render as $, toRpcSelect as A, StartsWithNode as B, QueryOptions as C, ProjectedEntity as D, FullEntity as E, ComparisonOperator as F, gt as G, and as H, ExistsNode as I, lt as J, gte as K, Expression as L, EntityFields as M, AndNode as N, SelectArg as O, ComparisonNode as P, or as Q, NotNode as R, OwnershipTransferredEvent as S, EntitySelection as T, eq as U, TypeOfNode as V, exists as W, ne as X, lte as Y, not as Z, EntityDeletedEvent as _, PatchEntityParameters as a, ArkivClient as at, EntityPatchedEvent as b, ExtendEntityReturnType as c, RpcAttributeSchemaEntry as ct, CreateEntityParameters as d, RpcQueryOptions as dt, startsWith as et, CreateEntityReturnType as f, RpcSelect as ft, EntityCreatedEvent as g, WatchEntityEventsParameters as h, ExecuteBatchReturnType as i, GetBlockTimingReturnType as it, Entity as j, SelectionFields as k, DeleteEntityParameters as l, RpcCreationFlags as lt, ChangeOwnershipReturnType as m, MimeType as n, PredictEntityKeysReturnType as nt, PatchEntityReturnType as o, ArkivRpcSchema as ot, ChangeOwnershipParameters as p, hasType as q, ExecuteBatchParameters as r, PredictedEntityKey as rt, ExtendEntityParameters as s, RpcAttribute as st, TxParams as t, PredictEntityKeysParameters as tt, DeleteEntityReturnType as u, RpcEntity as ut, EntityEvent as v, QueryReturnType as w, ExpiryExtendedEvent as x, EntityEventContext as y, OrNode as z };
-//# sourceMappingURL=index-DaNeJUw8.d.ts.map