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

package/dist/expiry-DRV29F1r.d.cts

@@ -1,79 +0,0 @@
-//#region src/entity/expiry.d.ts
-/**
- * The brand. Module-private and never exported, so the only way to obtain an {@link Expiry} is to
- * build one with {@link ExpirationTime} — a hand-written `{ minLifetime, expiresAt }` literal will
- * not typecheck, and neither will a bare number of seconds.
- */
-declare const validated: unique symbol;
-/**
- * How long an entity should live.
- *
- * This is the pair the ABI carries, and the engine resolves it as
- * `max(expiresAt, currentBlock + minLifetime)` — whichever is later. Build one with
- * {@link ExpirationTime}; there is no other way to make one.
- *
- * Which slot a value lands in also decides which rules govern it. `minLifetime` is a duration, so
- * it must come to a whole number of blocks. `expiresAt` is a block height, which is a whole number
- * by construction, so a wall-clock date rounds into it rather than being rejected.
- */
-type Expiry = {
-  /** Lifetime floor in blocks, counted from the block the transaction lands in. `0n` if unset. */
-  readonly minLifetime: bigint;
-  /**
-   * Absolute deadline: a block height, or a `Date` still to be placed against the current block.
-   * `0n` if unset.
-   */
-  readonly expiresAt: bigint | Date;
-  readonly [validated]: true;
-};
-/**
- * An expiry that is nothing but a duration — what the `ExpirationTime.from*` helpers return.
- *
- * Distinguished from a full {@link Expiry} by its `expiresAt` being the literal `0n`, which is what
- * keeps `atBlock(x, { atLeast: atBlock(y) })` from compiling: a deadline is not a floor.
- */
-type Lifetime = Expiry & {
-  readonly expiresAt: 0n;
-};
-/** The two `uint256` values the ABI carries, with every `Date` already placed. */
-type EncodedExpiry = {
-  /** Absolute target block height, or `0n` for a purely relative lifetime. */
-  expiresAt: bigint;
-  /** Relative floor in blocks, or `0n` for a purely absolute expiry. */
-  minLifetime: bigint;
-};
-/** What an expiry resolves to, given the chain's current block. */
-type ResolvedExpiry = EncodedExpiry & {
-  /** The block the entity will expire at — `max(expiresAt, currentBlock + minLifetime)`. */
-  target: bigint;
-};
-/** What the SDK needs to know about the chain to resolve an expiry. */
-type ExpiryContext = {
-  currentBlock: bigint;
-};
-/**
- * Resolves an expiry into the wire pair and the block the entity will expire at.
- *
- * Durations are converted to blocks at the nominal `BLOCK_TIME` (2 seconds), which makes them
- * **approximate**: block production is not a clock, so a lifetime asked for in days drifts if the
- * chain runs fast or slow. The block it was converted to comes back as
- * {@link ResolvedExpiry.target}, so the approximation is always observable rather than assumed.
- *
- * @throws {InvalidExpiryError} If the expiry is malformed, does not fit the `uint64` the wire
- * carries, or would leave the entity dead on arrival.
- */
-declare function resolveExpiry(expiry: Expiry, context: ExpiryContext): ResolvedExpiry;
-/**
- * A duration in seconds as a whole number of blocks.
- *
- * Arkiv counts lifetimes in blocks, so a duration that is not a whole number of them does not
- * describe anything the chain can store. Rather than silently round a caller's `3` up to two blocks
- * — four seconds, not what they asked for — this rejects it: a duration must be a positive multiple
- * of `BLOCK_TIME` (2 seconds). The {@link ExpirationTime} helpers all produce such multiples.
- *
- * @throws {InvalidExpiryError} If the duration is not a positive whole number of blocks' seconds.
- */
-declare function toBlocks(seconds: number): bigint;
-//#endregion
-export { ResolvedExpiry as a, Lifetime as i, Expiry as n, resolveExpiry as o, ExpiryContext as r, toBlocks as s, EncodedExpiry as t };
-//# sourceMappingURL=expiry-DRV29F1r.d.cts.map

package/dist/expiry-DRV29F1r.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"expiry-DRV29F1r.d.cts","names":[],"sources":["../src/entity/expiry.ts"],"sourcesContent":[],"mappings":";;;AAuBA;AAiBA;AAaA;AAQA,cAnDc,SAmDY,EAAA,OAAA,MAAG;AAM7B;AAeA;;;;;AAmEA;;;;;KA9HY,MAAA;;;;;;;+BAOmB;YACnB,SAAA;;;;;;;;KASA,QAAA,GAAW;;;;KAaX,aAAA;;;;;;;KAQA,cAAA,GAAiB;;;;;KAMjB,aAAA;;;;;;;;;;;;;;iBAeI,aAAA,SAAsB,iBAAiB,gBAAgB;;;;;;;;;;;iBAmEvD,QAAA"}

package/dist/flags-DCD26uhe.cjs

@@ -1,43 +0,0 @@
-const require_errors = require('./errors-DhV00966.cjs');
-
-//#region src/entity/flags.ts
-/** Bit positions in the `creationFlags` byte. Bits 2-7 are reserved and must be zero. */
-const READONLY_BIT = 1;
-const PERMISSIONLESS_EXTENSION_BIT = 2;
-/**
-* Packs creation flags into the `creationFlags` byte.
-*
-* @throws {InvalidCreationFlagsError} If a value is not a boolean.
-*/
-function encodeCreationFlags(flags = {}) {
-	for (const [name, value] of Object.entries(flags)) if (value !== void 0 && typeof value !== "boolean") throw new require_errors.InvalidCreationFlagsError(`"${name}" must be a boolean, got ${typeof value}`);
-	return (flags.readonly ? READONLY_BIT : 0) | (flags.permissionlessExtension ? PERMISSIONLESS_EXTENSION_BIT : 0);
-}
-/**
-* Reads the `creationFlags` byte back.
-*
-* @param raw - The `creationFlags` byte.
-* @throws {InvalidCreationFlagsError} Malformed input
-*/
-function decodeCreationFlags(raw) {
-	if (!Number.isInteger(raw) || raw < 0 || raw > 255) throw new require_errors.InvalidCreationFlagsError(`${raw} is not a byte`);
-	return {
-		readonly: (raw & READONLY_BIT) !== 0,
-		permissionlessExtension: (raw & PERMISSIONLESS_EXTENSION_BIT) !== 0,
-		raw
-	};
-}
-
-//#endregion
-Object.defineProperty(exports, 'decodeCreationFlags', {
-  enumerable: true,
-  get: function () {
-    return decodeCreationFlags;
-  }
-});
-Object.defineProperty(exports, 'encodeCreationFlags', {
-  enumerable: true,
-  get: function () {
-    return encodeCreationFlags;
-  }
-});

package/dist/flags-DUT2gHEU.js

@@ -1,33 +0,0 @@
-import { t as InvalidCreationFlagsError } from "./errors-D2E1GRjw.js";
-
-//#region src/entity/flags.ts
-/** Bit positions in the `creationFlags` byte. Bits 2-7 are reserved and must be zero. */
-const READONLY_BIT = 1;
-const PERMISSIONLESS_EXTENSION_BIT = 2;
-/**
-* Packs creation flags into the `creationFlags` byte.
-*
-* @throws {InvalidCreationFlagsError} If a value is not a boolean.
-*/
-function encodeCreationFlags(flags = {}) {
-	for (const [name, value] of Object.entries(flags)) if (value !== void 0 && typeof value !== "boolean") throw new InvalidCreationFlagsError(`"${name}" must be a boolean, got ${typeof value}`);
-	return (flags.readonly ? READONLY_BIT : 0) | (flags.permissionlessExtension ? PERMISSIONLESS_EXTENSION_BIT : 0);
-}
-/**
-* Reads the `creationFlags` byte back.
-*
-* @param raw - The `creationFlags` byte.
-* @throws {InvalidCreationFlagsError} Malformed input
-*/
-function decodeCreationFlags(raw) {
-	if (!Number.isInteger(raw) || raw < 0 || raw > 255) throw new InvalidCreationFlagsError(`${raw} is not a byte`);
-	return {
-		readonly: (raw & READONLY_BIT) !== 0,
-		permissionlessExtension: (raw & PERMISSIONLESS_EXTENSION_BIT) !== 0,
-		raw
-	};
-}
-
-//#endregion
-export { encodeCreationFlags as n, decodeCreationFlags as t };
-//# sourceMappingURL=flags-DUT2gHEU.js.map

package/dist/flags-DUT2gHEU.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flags-DUT2gHEU.js","names":[],"sources":["../src/entity/flags.ts"],"sourcesContent":["import { InvalidCreationFlagsError } from \"./errors\"\n\n/** Bit positions in the `creationFlags` byte. Bits 2-7 are reserved and must be zero. */\nconst READONLY_BIT = 0b0000_0001\nconst PERMISSIONLESS_EXTENSION_BIT = 0b0000_0010\n\n/**\n * The immutable properties an entity is created with. Both default to `false`.\n *\n * Creation flags are fixed at creation: there is no operation that changes them, so an entity is\n * whatever it was created as for its whole life.\n */\nexport type CreationFlags = {\n  /**\n   * The entity's attributes and payload can never be changed — only its expiry extended, its\n   * ownership transferred, and the entity deleted.\n   */\n  readonly?: boolean\n  /**\n   * Anyone, not just the owner, may extend the entity's expiry. Lets a third party keep something\n   * alive without being able to change it.\n   */\n  permissionlessExtension?: boolean\n}\n\n/** {@link CreationFlags} as read back, with every flag resolved and the raw byte alongside. */\nexport type ResolvedCreationFlags = {\n  readonly: boolean\n  permissionlessExtension: boolean\n  raw: number\n}\n\n/**\n * Packs creation flags into the `creationFlags` byte.\n *\n * @throws {InvalidCreationFlagsError} If a value is not a boolean.\n */\nexport function encodeCreationFlags(flags: CreationFlags = {}): number {\n  for (const [name, value] of Object.entries(flags)) {\n    if (value !== undefined && typeof value !== \"boolean\") {\n      throw new InvalidCreationFlagsError(`\"${name}\" must be a boolean, got ${typeof value}`)\n    }\n  }\n  return (\n    (flags.readonly ? READONLY_BIT : 0) |\n    (flags.permissionlessExtension ? PERMISSIONLESS_EXTENSION_BIT : 0)\n  )\n}\n\n/**\n * Reads the `creationFlags` byte back.\n *\n * @param raw - The `creationFlags` byte.\n * @throws {InvalidCreationFlagsError} Malformed input\n */\nexport function decodeCreationFlags(raw: number): ResolvedCreationFlags {\n  if (!Number.isInteger(raw) || raw < 0 || raw > 0xff) {\n    throw new InvalidCreationFlagsError(`${raw} is not a byte`)\n  }\n  return {\n    readonly: (raw & READONLY_BIT) !== 0,\n    permissionlessExtension: (raw & PERMISSIONLESS_EXTENSION_BIT) !== 0,\n    raw,\n  }\n}\n"],"mappings":";;;;AAGA,MAAM,eAAe;AACrB,MAAM,+BAA+B;;;;;;AAiCrC,SAAgB,oBAAoB,QAAuB,EAAE,EAAU;AACrE,MAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,MAAM,CAC/C,KAAI,UAAU,UAAa,OAAO,UAAU,UAC1C,OAAM,IAAI,0BAA0B,IAAI,KAAK,2BAA2B,OAAO,QAAQ;AAG3F,SACG,MAAM,WAAW,eAAe,MAChC,MAAM,0BAA0B,+BAA+B;;;;;;;;AAUpE,SAAgB,oBAAoB,KAAoC;AACtE,KAAI,CAAC,OAAO,UAAU,IAAI,IAAI,MAAM,KAAK,MAAM,IAC7C,OAAM,IAAI,0BAA0B,GAAG,IAAI,gBAAgB;AAE7D,QAAO;EACL,WAAW,MAAM,kBAAkB;EACnC,0BAA0B,MAAM,kCAAkC;EAClE;EACD"}

package/dist/index-BkqSnGJH.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-BkqSnGJH.d.ts","names":[],"sources":["../src/entity/errors.ts","../src/entity/events.ts","../src/entity/flags.ts","../src/entity/key.ts","../src/entity/params.ts"],"sourcesContent":[],"mappings":";;;;cACa,kBAAA,SAA2B,KAAA;;AAAxC;AAQA;AAQa,cARA,yBAAA,SAAkC,KAAA,CAQJ;EAY9B,WAAA,CAAA,MAAA,EAAA,MAAoB;;;cAZpB,gBAAA,SAAyB,KAAA;ECXzB,WAAA,CAAA,IAAA,EAAA,OAMX;AAGF;;cDca,mBAAA,SAA4B,KAAA;;AEjBzC;;;;;;AFXA;AAQa,cCHA,iBDG0B,EAAA,SAAa,CAAA;EAQvC,SAAA,IAAA,EAAA,eAAyB;EAYzB,SAAA,IAAA,EAAA,OAAoB;;;;ICvBpB,SAAA,OAMX,EAAA,IAAA;EAGU,CAAA,EAAA;;;;ECHA,CAAA,EAAA;IAcA,SAAA,IAAA,EAAA,QAAqB;IAWjB,SAAA,IAAA,EAAA,WAAmB;EAkBnB,CAAA,EAAA;;;;ACjDhB,CAAA,EAAA;EAOa,SAAA,IAA2B,EAAA,eAAA;EAK5B,SAAA,IAAS,EAAA,OAAA;EAWL,SAAA,MAAU,EAAA,SAAA,CAAA;IAkCV,SAAA,IAAA,EAAgB,SAAA;IAC9B,SAAA,IAAA,EAAA,WAAA;IACA,SAAA,OAAA,EAAA,IAAA;EACA,CAAA,EAAA;IACA,SAAA,IAAA,EAAA,SAAA;IAGO,SAAA,IAAA,EAAA,OAAA;IAOD,SAAA,OAAA,EAAA,IAAA;EAGJ,CAAA,CAAA;CAAG,EAAA;;;;IC7EM,SAAA,IAA+B,EAAA,SAAA;IAG/B,SAAA,IAMH,EAAA,WAAA;IAEE,SAAA,OAAa,EAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KHCb,eAAA,WAA0B;;;;;;ADdtC;AAQA;AAQA;AAYa,KEjBD,aAAA,GFiBqB;;;;ACvBjC;EASY,QAAA,CAAA,EAAA,OAAe;;;;ACH3B;EAcY,uBAAA,CAAqB,EAAA,OAAA;AAWjC,CAAA;AAkBA;KA7BY,qBAAA;;;ECpBC,GAAA,EAAA,MAA0B;AAOvC,CAAA;AAKA;AAWA;AAkCA;;;AAGE,iBD7Bc,mBAAA,CC6Bd,KAAA,CAAA,ED7ByC,aC6BzC,CAAA,EAAA,MAAA;;;;;;;iBDXc,mBAAA,eAAkC;;;;cCjDrC;AHLb;AAQA;AAQA;AAYA;;cGhBa;;AFPb;AASA;KEGY,SAAA,mBAA4B;;;ADNxC;AAcA;AAWA;AAkBA;;;;ACjDa,iBAuBG,UAAA,CAAA,CAvBuB,EAAA,MAAA;;;;;;;;;iBAyDvB,gBAAA;;;;;;EC5DH;EAGA,KAAA,EDgEJ,OChEI;EAQD;;;;;;QD+DJ;;;IAGJ;;;;;;AH/ES,cIEA,cJFmB,EAAQ,MAAK;AAQ7C;AAQa,cIXA,aJWyB,EAAA;EAYzB,SAAA,MAAA,EAAA,CAAA;;;;ECvBA,SAAA,MAAA,EAAA,CAAA;AASb,CAAA;KGDY,aAAA,WAAwB,4BAA4B"}

package/dist/index-C7fbakoI.d.cts

@@ -1,278 +0,0 @@
-import { K as TypeTag } from "./index-CIcHPx2j.cjs";
-import { L as Expression, O as SelectArg, at as ArkivClient, ft as RpcSelect, j as Entity } from "./index-Dv16LO2s.cjs";
-import { Hex } from "viem";
-
-//#region src/query/engine.d.ts
-declare const MAX_LIMIT = 200;
-/** One `arkiv_query` call. */
-type QueryRequest = {
-  /** The query expression, already rendered. */
-  query: string;
-  /** What to return. */
-  select: RpcSelect;
-  /** Page size, up to {@link MAX_LIMIT}. Defaults to the node's own page size. */
-  limit?: number | undefined;
-  /** Cursor from a previous page. */
-  cursor?: string | undefined;
-  /** Block height to read at. Defaults to the head. */
-  atBlock?: bigint | undefined;
-};
-/** One page of results. */
-type QueryResponse = {
-  entities: Entity[];
-  /** The block the page was read at — the same for every page of a paginated query. */
-  blockNumber: bigint;
-  /** The cursor for the next page, or `undefined` when this was the last one. */
-  cursor: string | undefined;
-};
-/**
- * Runs one query and decodes the page it returns.
- *
- * @throws {QueryError} If the node rejects the query.
- */
-declare function runQuery(client: ArkivClient, request: QueryRequest): Promise<QueryResponse>;
-//#endregion
-//#region src/query/errors.d.ts
-/**
- * A predicate asked for an operator the query language does not define for that type.
- *
- * The operator × type matrix is part of the language, not a policy: a range comparison on an
- * equality-only type is a **parse error** at the node, not an empty result. Catching it here turns
- * a round trip and an RPC error code into a stack trace pointing at the call site.
- *
- * | | `=` `!=` | `<` `<=` `>` `>=` | `STARTSWITH` |
- * | --- | --- | --- | --- |
- * | `bool` | yes | no | no |
- * | `i32` `u64` `u256` `dec` | yes | yes | no |
- * | `str` | yes | no | yes |
- * | `addr` `key` `bytes32` | yes | no | no |
- */
-declare class UnsupportedOperatorError extends Error {
-  /** The attribute the predicate names. */
-  readonly attributeName: string;
-  /** The operator, as it would have been written in the query. */
-  readonly operator: string;
-  /** The type of the value it was applied to. */
-  readonly tag: TypeTag;
-  constructor(attributeName: string, operator: string, tag: TypeTag, hint?: string);
-}
-/**
- * A predicate could not be expressed in the query language for a reason other than its operator —
- * a system attribute that is returned in results but cannot be filtered on, a system attribute
- * compared against the wrong type, or a combinator with nothing to combine.
- */
-declare class InvalidPredicateError extends Error {
-  /** The attribute the predicate names, where there is one. */
-  readonly attributeName: string | undefined;
-  constructor(message: string, attributeName?: string);
-}
-/**
- * What a node rejected a query for. Part of the frozen RPC surface, so it is safe to branch on —
- * a `"cursor"` failure means start the query again, a `"block"` failure means the node no longer
- * retains that height, and the rest mean the query itself needs fixing.
- */
-type QueryErrorKind = /** The query string does not parse. `data` locates it: `{ position, expected, got }`. */
-"parse"
-/** A predicate is well-formed but ill-typed — a range operator on an equality-only type, an unknown tag. */ | "type"
-/** A literal failed validation — an `i32` out of range, a bad EIP-55 checksum, more than 18 decimal places. */ | "literal"
-/** A node budget was exceeded — query length, predicate count, nesting depth, bitmap operations. */ | "limits"
-/** The cursor expired, is malformed, or belongs to a different query, block or selection. */ | "cursor"
-/** `atBlock` is outside the range the node retains. */ | "block";
-/**
- * The node rejected a query.
- *
- * These codes are part of the frozen `arkiv_query` surface, so {@link kind} and {@link data} are
- * stable enough to branch on — which the underlying JSON-RPC error is not, because the codes
- * overlap Ethereum's own EIP-1474 numbering and get wrapped accordingly on the way up.
- *
- * @example
- * try {
- *   await result.next()
- * } catch (error) {
- *   if (error instanceof QueryError && error.kind === "cursor") {
- *     // The page is gone — start the query over.
- *   }
- * }
- */
-declare class QueryError extends Error {
-  /** Which failure this is. */
-  readonly kind: QueryErrorKind;
-  /** The JSON-RPC error code. */
-  readonly code: number;
-  /** The machine-readable detail the node sent, if any — e.g. `{ position, expected, got }`. */
-  readonly data: unknown;
-  /** The query string that was rejected. */
-  readonly query: string;
-  constructor(kind: QueryErrorKind, code: number, query: string, data: unknown, detail?: string);
-}
-//#endregion
-//#region src/query/queryResult.d.ts
-/** Fetches the page a cursor points at. */
-type FetchPage<TEntity> = (cursor: string) => Promise<QueryResult<TEntity>>;
-/**
- * One page of query results.
- *
- * A page is immutable: {@link next} returns the following page rather than mutating this one, so a
- * page that has been read stays readable.
- *
- * @typeParam TEntity - The shape of each entity, inferred from the selection by `client.select()`.
- *
- * @example
- * let page = await client.select({ key: true }).where(eq("category", "docs")).limit(100).fetch()
- * while (page.hasNextPage()) {
- *   page = await page.next()
- * }
- */
-declare class QueryResult<TEntity = Entity> {
-  /** The entities on this page. */
-  readonly entities: readonly TEntity[];
-  /**
-   * The block this page was read at.
-   *
-   * Every page of one walk reads the same block — the cursor is bound to it — so results cannot
-   * shift under a paginating reader.
-   */
-  readonly blockNumber: bigint;
-  /** The cursor for the next page, or `undefined` when this was the last one. */
-  readonly cursor: string | undefined;
-  private readonly fetchPage;
-  constructor(entities: readonly TEntity[], blockNumber: bigint, cursor: string | undefined, fetchPage: FetchPage<TEntity>);
-  /**
-   * Whether another page follows.
-   *
-   * The node omits the cursor once nothing remains, so this is an answer rather than the guess a
-   * short final page would be — a full last page is reported correctly.
-   */
-  hasNextPage(): boolean;
-  /**
-   * Fetches the next page.
-   *
-   * @throws {NoMoreResultsError} If this was the last page — check {@link hasNextPage} first.
-   * @throws {QueryError} If the node rejects the request; `kind === "cursor"` means the cursor
-   * expired and the walk has to start again.
-   */
-  next(): Promise<QueryResult<TEntity>>;
-}
-//#endregion
-//#region src/query/queryBuilder.d.ts
-/**
- * Builds and runs a query.
- *
- * The selection is fixed when the builder is created and the filter is added by chaining, so the
- * result type is known before a single predicate is written. Create one with `client.select(...)`
- * rather than constructing it directly — that is what infers the entity shape from the selection.
- *
- * Every filter added with {@link where}, {@link ownedBy} and {@link createdBy} must hold; use
- * {@link or} for alternatives inside one call.
- *
- * @typeParam TEntity - The projected entity shape, inferred from the selection by `client.select()`.
- *
- * @example
- * import { createPublicClient } from "@arkiv-network/sdk"
- * import { i32 } from "@arkiv-network/sdk/attr"
- * import { tiramisu } from "@arkiv-network/sdk/chains"
- * import { eq, gte, or } from "@arkiv-network/sdk/query"
- * import { http } from "viem"
- *
- * const client = createPublicClient({ chain: tiramisu, transport: http() })
- *
- * const page = await client
- *   .select({ key: true, attributes: true })
- *   .where(gte("level", i32(10)), or(eq("status", "open"), eq("status", "review")))
- *   .ownedBy(owner)
- *   .limit(100)
- *   .fetch()
- *
- * for (const entity of page.entities) console.log(entity.key, entity.attributes)
- */
-declare class SelectQueryBuilder<TEntity = Entity> {
-  private readonly _client;
-  private readonly _select;
-  private readonly _filters;
-  private _ownedBy;
-  private _createdBy;
-  private _limit;
-  private _cursor;
-  private _atBlock;
-  constructor(client: ArkivClient, selection?: SelectArg);
-  /**
-   * Adds filters. Everything passed here, and across repeated calls, must hold.
-   *
-   * @param expressions - The expressions, as separate arguments or one array.
-   *
-   * @example
-   * builder.where(eq("category", "docs"))
-   * builder.where(gte("level", i32(10)), lt("level", i32(20)))
-   * builder.where(or(eq("status", "open"), not(exists("closedAt"))))
-   */
-  where(expressions: readonly Expression[]): this;
-  where(...expressions: Expression[]): this;
-  /**
-   * Restricts the results to entities this account owns — shorthand for
-   * `where(eq("$owner", addr(owner)))`. Calling it again replaces the filter.
-   *
-   * @example
-   * builder.ownedBy("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")
-   */
-  ownedBy(owner: Hex): this;
-  /**
-   * Restricts the results to entities this account created — shorthand for
-   * `where(eq("$creator", addr(creator)))`. Calling it again replaces the filter.
-   *
-   * The creator never changes; the owner does, so these differ after a transfer.
-   */
-  createdBy(creator: Hex): this;
-  /**
-   * Sets the page size, up to the node maximum of 200. Without it the node picks the page size.
-   *
-   * @example
-   * builder.limit(100)
-   */
-  limit(limit: number): this;
-  /**
-   * Starts from a cursor returned by an earlier page.
-   *
-   * Pagination normally goes through {@link QueryResult.next}, which carries the cursor for you;
-   * this is for resuming a walk in a later process. A cursor is bound to the query, block and
-   * selection it came from, so it must be used with an identically-built query.
-   */
-  cursor(cursor: string): this;
-  /**
-   * Reads the state as of a given block rather than the head. The block must be within the range
-   * the node retains.
-   *
-   * @example
-   * builder.atBlock(1_297_000n)
-   */
-  atBlock(block: bigint): this;
-  /**
-   * The query string this builder will send — the same text the node parses.
-   *
-   * @throws {InvalidPredicateError} If no filter has been added.
-   */
-  toString(): string;
-  /**
-   * Runs the query and returns the first page.
-   *
-   * @throws {InvalidPredicateError} If no filter has been added.
-   * @throws {QueryError} If the node rejects the query.
-   *
-   * @example
-   * const page = await client.select({ key: true }).where(eq("category", "docs")).fetch()
-   * page.entities        // this page
-   * await page.next()    // the next one
-   */
-  fetch(): Promise<QueryResult<TEntity>>;
-  /**
-   * Walks every page, yielding one entity at a time.
-   *
-   * @example
-   * for await (const entity of client.select({ key: true }).where(eq("category", "docs"))) {
-   *   console.log(entity.key)
-   * }
-   */
-  [Symbol.asyncIterator](): AsyncGenerator<TEntity>;
-}
-//#endregion
-export { QueryErrorKind as a, QueryRequest as c, QueryError as i, QueryResponse as l, QueryResult as n, UnsupportedOperatorError as o, InvalidPredicateError as r, MAX_LIMIT as s, SelectQueryBuilder as t, runQuery as u };
-//# sourceMappingURL=index-C7fbakoI.d.cts.map

package/dist/index-C7fbakoI.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-C7fbakoI.d.cts","names":[],"sources":["../src/query/engine.ts","../src/query/errors.ts","../src/query/queryResult.ts","../src/query/queryBuilder.ts"],"sourcesContent":[],"mappings":";;;;;cAUa,SAAA;;AAAA,KAGD,YAAA,GAHU;EAGV;EAcA,KAAA,EAAA,MAAA;EAaU;EAAiB,MAAA,EAvB7B,SAuB6B;EAAsB;EAAuB,KAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAR;EAAO,MAAA,CAAA,EAAA,MAAA,GAAA,SAAA;;;;ACxBnF;AAMgB,KDKJ,aAAA,GCLI;EAE4C,QAAA,EDIhD,MCJgD,EAAA;EARd;EAAK,WAAA,EAAA,MAAA;EAyBtC;EAgBD,MAAA,EAAA,MAAA,GAAc,SAAA;AAwC1B,CAAA;;;;;;iBDzDsB,QAAA,SAAiB,sBAAsB,eAAe,QAAQ;;;;;;;AA9BpF;AAGA;AAcA;AAaA;;;;;;;cCxBa,wBAAA,SAAiC,KAAA;;EAAjC,SAAA,aAAA,EAAA,MAAyB;EAMtB;EAE4C,SAAA,QAAA,EAAA,MAAA;EARd;EAAK,SAAA,GAAA,EAMnC,OANmC;EAyBtC,WAAA,CAAA,aAAsB,EAAA,MAAA,EAAA,QAAa,EAAA,MAAA,EAAA,GAAA,EAjBY,OAiBZ,EAAA,IAAA,CAAA,EAAA,MAAA;AAgBhD;AAwCA;;;;;cAxDa,qBAAA,SAA8B,KAAA;;;ECrCtC,WAAA,CAAS,OAAA,EAAA,MAAA,EAAA,aAAA,CAAA,EAAA,MAAA;;;;;AAgBd;;AAE8B,KDmClB,cAAA;;+GCSwB;kHAApB;;;ACzBhB,0DAA0C,OAAA;;;;;;;;;;;;;;;;;cFwD7B,UAAA,SAAmB,KAAA;;iBAEf;;;;;;;oBAQG;;;;;KCvGf,yCAAyC,QAAQ,YAAY;;;AFMlE;AAGA;AAcA;AAaA;;;;;;;;;ACxBa,cCIA,WDJyB,CAAA,UCIH,MDJG,CAAA,CAAA;EAMtB;EAE4C,SAAA,QAAA,EAAA,SCF9B,ODE8B,EAAA;EARd;;AAyB9C;AAgBA;AAwCA;;EAUoB,SAAA,WAAA,EAAA,MAAA;EAVY;EAAK,SAAA,MAAA,EAAA,MAAA,GAAA,SAAA;;iCC7Dd,uEAGR,UAAU;;AAtCoB;;;;;EAmBhC,WAAA,CAAA,CAAA,EAAW,OAAA;EAAW;;;;;;;EA8CnB,IAAA,CAAA,CAAA,EAAA,OAAA,CAAQ,WAAR,CAAoB,OAApB,CAAA,CAAA;;;;AFrDhB;AAcA;AAaA;;;;;;;;;ACxBA;;;;;AAyBA;AAgBA;AAwCA;;;;;;;;AChG6C;;;;AAGQ,cCqCxC,kBDrCwC,CAAA,UCqCX,MDrCW,CAAA,CAAA;EAgBxC,iBAAW,OAAA;EAAW,iBAAA,OAAA;EAEL,iBAAA,QAAA;EAcP,QAAA,QAAA;EAGE,QAAA,UAAA;EAAV,QAAA,MAAA;EA2BqB,QAAA,OAAA;EAAZ,QAAA,QAAA;EAAR,WAAA,CAAA,MAAA,ECfM,WDeN,EAAA,SAAA,CAAA,ECf+B,SDe/B;EAAO;;;;ACzBvB;;;;;;EAuCiB,KAAA,CAAA,WAAA,EAAA,SAda,UAcb,EAAA,CAAA,EAAA,IAAA;EAWI,KAAA,CAAA,GAAA,WAAA,EAxBG,UAwBH,EAAA,CAAA,EAAA,IAAA;EAuEgB;;;;;;;iBAlFpB;;;;;;;qBAWI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuEJ,QAAQ,YAAY;;;;;;;;;GAqB3B,MAAA,CAAO,aAAA,KAAkB,eAAe"}