@xyo-network/sdk 2.102.4 → 7.0.2

package/dist/_pkg/sdk-protocol/_pkg/payload-wrapper/neutral/PayloadDataWrapper.d.ts

@@ -0,0 +1,17 @@
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { Payload } from '../../payload-model/neutral/index.ts';
+import type { PayloadLoaderFactory } from './PayloadWrapperBase.ts';
+import { PayloadWrapperBase } from './PayloadWrapperBase.ts';
+export declare const isPayloadDataWrapper: (value?: unknown) => value is PayloadDataWrapper;
+export declare class PayloadDataWrapper<TPayload extends Payload = Payload> extends PayloadWrapperBase<TPayload> {
+    protected static loaderFactory: PayloadLoaderFactory | null;
+    protected constructor(payload: TPayload);
+    static as<T extends Payload = Payload>(value: unknown): PayloadDataWrapper<T> | null;
+    static load(address: XyoAddress): Promise<PayloadDataWrapper<Payload> | null>;
+    static parse<T extends Payload>(payload?: unknown): PayloadDataWrapper<T> | undefined;
+    static setLoaderFactory(factory: PayloadLoaderFactory | null): void;
+    static tryParse<T extends Payload>(obj: unknown): PayloadDataWrapper<T> | undefined;
+    static wrap<T extends Payload>(payload?: T | PayloadDataWrapper<T>): PayloadDataWrapper<T>;
+    static wrappedMap<T extends Payload>(payloads: (T | PayloadDataWrapper<T>)[]): Promise<Record<string, PayloadDataWrapper<T>>>;
+    validate(): Promise<Error[]>;
+}

package/dist/_pkg/sdk-protocol/_pkg/payload-wrapper/neutral/PayloadWrapper.d.ts

@@ -0,0 +1,5 @@
+import type { Payload } from '../../payload-model/neutral/index.ts';
+import { PayloadDataWrapper } from './PayloadDataWrapper.ts';
+export declare const isPayloadWrapper: (value?: unknown) => value is PayloadWrapper;
+export declare class PayloadWrapper<TPayload extends Payload = Payload> extends PayloadDataWrapper<TPayload> {
+}

package/dist/_pkg/sdk-protocol/_pkg/payload-wrapper/neutral/PayloadWrapperBase.d.ts

@@ -0,0 +1,22 @@
+import type { Promisable } from '@xylabs/sdk';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { Payload } from '../../payload-model/neutral/index.ts';
+export type PayloadLoader = (address: XyoAddress) => Promise<Payload | null>;
+export type PayloadLoaderFactory = () => PayloadLoader;
+export declare const isPayloadWrapperBase: (value?: unknown) => value is PayloadWrapperBase;
+export declare class PayloadWrapperBase<TPayload extends Payload = Payload> {
+    private _errors?;
+    payload: TPayload;
+    protected constructor(payload: TPayload);
+    static unwrap<TPayload extends Payload = Payload>(payload?: TPayload): TPayload | undefined;
+    static unwrap<TPayload extends Payload = Payload, TWrapper extends PayloadWrapperBase<TPayload> = PayloadWrapperBase<TPayload>>(payload: TPayload | TWrapper): TPayload;
+    static unwrap<TPayload extends Payload = Payload, TWrapper extends PayloadWrapperBase<TPayload> = PayloadWrapperBase<TPayload>>(payload: (TPayload | TWrapper)[]): TPayload[];
+    static unwrapSinglePayload<TPayload extends Payload = Payload>(payload?: TPayload): TPayload | undefined;
+    static unwrapSinglePayload<TPayload extends Payload = Payload, TWrapper extends PayloadWrapperBase<TPayload> = PayloadWrapperBase<TPayload>>(payload: TPayload | TWrapper): TPayload;
+    dataHash(): Promise<import("@xylabs/sdk").BrandedHash>;
+    getErrors(): Promise<Error[]>;
+    getValid(): Promise<boolean>;
+    hash(): Promise<import("@xylabs/sdk").BrandedHash>;
+    schema(): string;
+    validate(): Promisable<Error[]>;
+}

package/dist/_pkg/sdk-protocol/_pkg/payload-wrapper/neutral/SchemaType.d.ts

@@ -0,0 +1,5 @@
+import type { Payload } from '../../payload-model/neutral/index.ts';
+import type { JSONSchemaType } from 'ajv';
+export declare const Uint256RegEx: RegExp;
+export declare const payloadPropertiesJsonSchema: JSONSchemaType<Payload>['properties'];
+export declare const payloadJsonSchema: JSONSchemaType<Payload>;

package/dist/_pkg/sdk-protocol/_pkg/payload-wrapper/neutral/index.d.ts

@@ -0,0 +1,3 @@
+export * from './PayloadWrapper.ts';
+export * from './PayloadWrapperBase.ts';
+export * from './SchemaType.ts';

package/dist/_pkg/sdk-protocol/_pkg/payload-wrapper/neutral/index.mjs

@@ -0,0 +1,156 @@
+// src/PayloadDataWrapper.ts
+import { assertEx as assertEx2 } from "@xylabs/sdk";
+import { PayloadValidator } from "../../payload-validator/neutral/index.mjs";
+
+// src/PayloadWrapperBase.ts
+import { assertEx } from "@xylabs/sdk";
+import { PayloadBuilder } from "../../payload-builder/neutral/index.mjs";
+import { isAnyPayload } from "../../payload-model/neutral/index.mjs";
+var isPayloadWrapperBase = (value) => {
+  return value instanceof PayloadWrapperBase;
+};
+var PayloadWrapperBase = class {
+  _errors;
+  payload;
+  constructor(payload) {
+    this.payload = payload;
+  }
+  static unwrap(payload) {
+    return Array.isArray(payload) ? payload.map((payload2) => this.unwrapSinglePayload(payload2)) : this.unwrapSinglePayload(payload);
+  }
+  static unwrapSinglePayload(payload) {
+    if (payload === void 0) {
+      return;
+    }
+    if (Array.isArray(payload)) {
+      throw new TypeError("Can not unwrap value that is an array");
+    }
+    if (isPayloadWrapperBase(payload)) {
+      return payload.payload;
+    }
+    if (isAnyPayload(payload)) {
+      return payload;
+    }
+    throw new TypeError("Can not unwrap an object that is not a PayloadWrapper or Payload");
+  }
+  async dataHash() {
+    return await PayloadBuilder.dataHash(this.payload);
+  }
+  async getErrors() {
+    this._errors = this._errors ?? await this.validate();
+    return this._errors;
+  }
+  async getValid() {
+    const errors = await this.getErrors();
+    return errors.length === 0;
+  }
+  async hash() {
+    return await PayloadBuilder.hash(this.payload);
+  }
+  // intentionally a function to prevent confusion with payload
+  schema() {
+    return assertEx(this.payload?.schema, () => "Missing payload schema");
+  }
+  validate() {
+    return [];
+  }
+};
+
+// src/PayloadDataWrapper.ts
+var PayloadDataWrapper = class _PayloadDataWrapper extends PayloadWrapperBase {
+  static loaderFactory = null;
+  constructor(payload) {
+    super(payload);
+  }
+  static as(value) {
+    return value instanceof this ? value : null;
+  }
+  static async load(address) {
+    if (this.loaderFactory === null) {
+      console.warn("No loader factory set");
+      return null;
+    }
+    const payload = await this.loaderFactory()(address);
+    return payload ? new _PayloadDataWrapper(payload) : null;
+  }
+  static parse(payload) {
+    const hydratedObj = typeof payload === "string" ? JSON.parse(payload) : payload;
+    return this.wrap(hydratedObj);
+  }
+  static setLoaderFactory(factory) {
+    this.loaderFactory = factory;
+  }
+  static tryParse(obj) {
+    if (obj === void 0 || obj === null) return;
+    try {
+      return this.parse(obj);
+    } catch {
+      return void 0;
+    }
+  }
+  static wrap(payload) {
+    assertEx2(!Array.isArray(payload), () => "Array can not be converted to PayloadWrapper");
+    switch (typeof payload) {
+      case "object": {
+        if (payload instanceof this) {
+          return payload;
+        }
+        const wrappedPayload = isPayloadWrapperBase(payload) ? payload.payload : payload;
+        return new _PayloadDataWrapper(wrappedPayload);
+      }
+      default: {
+        throw new Error(`Can only parse objects [${typeof payload}]`);
+      }
+    }
+  }
+  static async wrappedMap(payloads) {
+    const result = {};
+    await Promise.all(
+      payloads.map(async (payload) => {
+        const wrapper = this.wrap(payload);
+        const dataHash = String(await wrapper.dataHash());
+        result[dataHash] = wrapper;
+      })
+    );
+    return result;
+  }
+  async validate() {
+    const validator = new PayloadValidator(this.payload);
+    return await validator.validate();
+  }
+};
+
+// src/PayloadWrapper.ts
+var isPayloadWrapper = (value) => {
+  return isPayloadWrapperBase(value);
+};
+var PayloadWrapper = class extends PayloadDataWrapper {
+};
+
+// src/SchemaType.ts
+import { HashRegEx, HexRegExMinMax } from "@xylabs/sdk";
+import { SchemaRegEx } from "../../payload-model/neutral/index.mjs";
+var Uint256RegEx = HexRegExMinMax(0, 32);
+var payloadPropertiesJsonSchema = {
+  $sources: {
+    type: "array",
+    items: { type: "string", pattern: HashRegEx.source }
+  },
+  schema: { pattern: SchemaRegEx.source, type: "string" }
+};
+var payloadJsonSchema = {
+  $id: "https://schemas.xyo.network/2.0/payload",
+  additionalProperties: true,
+  properties: payloadPropertiesJsonSchema,
+  required: ["schema"],
+  type: "object"
+};
+export {
+  PayloadWrapper,
+  PayloadWrapperBase,
+  Uint256RegEx,
+  isPayloadWrapper,
+  isPayloadWrapperBase,
+  payloadJsonSchema,
+  payloadPropertiesJsonSchema
+};

package/dist/_pkg/sdk-protocol/_pkg/pqc/neutral/MlDsa.d.ts

@@ -0,0 +1,19 @@
+export interface MlDsaKeyPair {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}
+export declare class MlDsa {
+    static readonly bundleLength: number;
+    static readonly publicKeyLength = 1952;
+    static readonly secretKeyLength = 4032;
+    static readonly signatureLength = 3309;
+    static addressFromPublicKey(publicKey: ArrayBufferLike): ArrayBufferLike;
+    static bundle(publicKey: ArrayBufferLike, signature: ArrayBufferLike): ArrayBufferLike;
+    static keygen(seed?: ArrayBufferLike): MlDsaKeyPair;
+    static sign(secretKey: ArrayBufferLike, message: ArrayBufferLike): ArrayBufferLike;
+    static unbundle(bundle: ArrayBufferLike): {
+        publicKey: ArrayBufferLike;
+        signature: ArrayBufferLike;
+    };
+    static verify(publicKey: ArrayBufferLike, message: ArrayBufferLike, signature: ArrayBufferLike): boolean;
+}

package/dist/_pkg/sdk-protocol/_pkg/pqc/neutral/index.d.ts

@@ -0,0 +1 @@
+export * from './MlDsa.ts';

package/dist/_pkg/sdk-protocol/_pkg/pqc/neutral/index.mjs

@@ -0,0 +1,46 @@
+// src/MlDsa.ts
+import { ml_dsa65 } from "@noble/post-quantum/ml-dsa.js";
+import { toUint8Array } from "@xylabs/sdk";
+import { Data } from "../../data/neutral/index.mjs";
+var MlDsa = class {
+  static bundleLength = 1952 + 3309;
+  static publicKeyLength = 1952;
+  static secretKeyLength = 4032;
+  static signatureLength = 3309;
+  static addressFromPublicKey(publicKey) {
+    const data = new Data(publicKey.byteLength, publicKey);
+    return data.keccak256.slice(12);
+  }
+  static bundle(publicKey, signature) {
+    const pk = toUint8Array(publicKey);
+    const sig = toUint8Array(signature);
+    const out = new Uint8Array(pk.byteLength + sig.byteLength);
+    out.set(pk, 0);
+    out.set(sig, pk.byteLength);
+    return out.buffer;
+  }
+  static keygen(seed) {
+    const seedBytes = seed === void 0 ? void 0 : toUint8Array(seed, 32);
+    return ml_dsa65.keygen(seedBytes);
+  }
+  static sign(secretKey, message) {
+    const sig = ml_dsa65.sign(toUint8Array(message), toUint8Array(secretKey));
+    return sig.buffer;
+  }
+  static unbundle(bundle) {
+    if (bundle.byteLength !== this.bundleLength) {
+      throw new Error(`Invalid ML-DSA signature bundle length [${bundle.byteLength} !== ${this.bundleLength}]`);
+    }
+    const bytes = toUint8Array(bundle);
+    return {
+      publicKey: bytes.slice(0, this.publicKeyLength).buffer,
+      signature: bytes.slice(this.publicKeyLength).buffer
+    };
+  }
+  static verify(publicKey, message, signature) {
+    return ml_dsa65.verify(toUint8Array(signature), toUint8Array(message), toUint8Array(publicKey));
+  }
+};
+export {
+  MlDsa
+};

package/dist/_pkg/sdk-protocol/_pkg/previous-hash-store/neutral/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../../previous-hash-store-indexeddb/neutral/index.ts';
+export * from '../../previous-hash-store-model/neutral/index.ts';
+export * from '../../previous-hash-store-storage/neutral/index.ts';

package/dist/_pkg/sdk-protocol/_pkg/previous-hash-store/neutral/index.mjs

@@ -0,0 +1,4 @@
+// src/index.ts
+export * from "../../previous-hash-store-indexeddb/neutral/index.mjs";
+export * from "../../previous-hash-store-model/neutral/index.mjs";
+export * from "../../previous-hash-store-storage/neutral/index.mjs";

package/dist/_pkg/sdk-protocol/_pkg/previous-hash-store-indexeddb/neutral/IndexedDbPreviousHashStore.d.ts

@@ -0,0 +1,26 @@
+import type { Hash } from '@xylabs/sdk';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { PreviousHashStore } from '../../previous-hash-store-model/neutral/index.ts';
+import type { DBSchema } from 'idb';
+export interface PreviousHashStoreSchemaV1 extends DBSchema {
+    'previous-hash': {
+        key: string;
+        value: string;
+    };
+}
+export declare class IndexedDbPreviousHashStore implements PreviousHashStore {
+    static readonly CurrentSchemaVersion = 1;
+    private readonly db;
+    constructor();
+    /**
+     * The database name.
+     */
+    get dbName(): "xyo";
+    /**
+     * The name of the object store.
+     */
+    get storeName(): "previous-hash";
+    getItem(address: XyoAddress): Promise<Hash | null>;
+    removeItem(address: XyoAddress): Promise<void>;
+    setItem(address: XyoAddress, previousHash: string): Promise<void>;
+}

package/dist/_pkg/sdk-protocol/_pkg/previous-hash-store-indexeddb/neutral/index.d.ts

@@ -0,0 +1 @@
+export * from './IndexedDbPreviousHashStore.ts';

package/dist/_pkg/sdk-protocol/_pkg/previous-hash-store-indexeddb/neutral/index.mjs

@@ -0,0 +1,41 @@
+// src/IndexedDbPreviousHashStore.ts
+import { openDB } from "idb";
+var IndexedDbPreviousHashStore = class _IndexedDbPreviousHashStore {
+  static CurrentSchemaVersion = 1;
+  db;
+  constructor() {
+    this.db = openDB(
+      this.dbName,
+      _IndexedDbPreviousHashStore.CurrentSchemaVersion,
+      { upgrade: (db) => db.createObjectStore(this.storeName) }
+    );
+  }
+  /**
+   * The database name.
+   */
+  get dbName() {
+    return "xyo";
+  }
+  /**
+   * The name of the object store.
+   */
+  get storeName() {
+    return "previous-hash";
+  }
+  async getItem(address) {
+    const db = await this.db;
+    const value = await db.get(this.storeName, address);
+    return value ?? null;
+  }
+  async removeItem(address) {
+    const db = await this.db;
+    await db.delete(this.storeName, address);
+  }
+  async setItem(address, previousHash) {
+    const db = await this.db;
+    await db.put(this.storeName, previousHash, address);
+  }
+};
+export {
+  IndexedDbPreviousHashStore
+};

package/dist/_pkg/sdk-protocol/_pkg/previous-hash-store-model/neutral/PreviousHashStore.d.ts

@@ -0,0 +1,7 @@
+import type { Hash } from '@xylabs/sdk';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+export interface PreviousHashStore {
+    getItem(address: XyoAddress): Hash | null | Promise<Hash | null>;
+    removeItem(address: XyoAddress): void | Promise<void>;
+    setItem(address: XyoAddress, previousHash: Hash): void | Promise<void>;
+}

package/dist/_pkg/sdk-protocol/_pkg/previous-hash-store-model/neutral/index.d.ts

@@ -0,0 +1 @@
+export * from './PreviousHashStore.ts';

package/dist/_pkg/sdk-protocol/_pkg/previous-hash-store-model/neutral/index.mjs

@@ -0,0 +1 @@
+

package/dist/_pkg/sdk-protocol/_pkg/previous-hash-store-storage/neutral/NamespacedStorage.d.ts

@@ -0,0 +1,9 @@
+export type StorageArea = 'local' | 'session' | 'page';
+export declare class NamespacedStorage<T> {
+    private readonly backend;
+    private readonly prefix;
+    constructor(area: StorageArea, namespace: string);
+    get(key: string): T | undefined;
+    remove(key: string): void;
+    set(key: string, value: T): void;
+}

package/dist/_pkg/sdk-protocol/_pkg/previous-hash-store-storage/neutral/StoragePreviousHashStore.d.ts

@@ -0,0 +1,23 @@
+import type { Hash } from '@xylabs/sdk';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { PreviousHashStore } from '../../previous-hash-store-model/neutral/index.ts';
+import type { StorageArea } from './NamespacedStorage.ts';
+export type Storage = StorageArea;
+export interface StoragePreviousHashOpts {
+    namespace?: string;
+    type?: Storage;
+}
+export declare class StoragePreviousHashStore implements PreviousHashStore {
+    static readonly DefaultNamespace = "xyo-previous-hash-store";
+    static readonly DefaultStorageType: Storage;
+    private _namespace;
+    private _storage;
+    private _type;
+    constructor(opts?: StoragePreviousHashOpts);
+    private get storage();
+    get namespace(): string;
+    get type(): Storage;
+    getItem(address: XyoAddress): Promise<Hash | null>;
+    removeItem(address: XyoAddress): Promise<void>;
+    setItem(address: XyoAddress, previousHash: Hash): Promise<void>;
+}

package/dist/_pkg/sdk-protocol/_pkg/previous-hash-store-storage/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './NamespacedStorage.ts';
+export * from './StoragePreviousHashStore.ts';

package/dist/_pkg/sdk-protocol/_pkg/previous-hash-store-storage/neutral/index.mjs

@@ -0,0 +1,103 @@
+// src/NamespacedStorage.ts
+var InMemoryBackend = class {
+  data = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.data.get(key) ?? null;
+  }
+  remove(key) {
+    this.data.delete(key);
+  }
+  set(key, value) {
+    this.data.set(key, value);
+  }
+};
+var WebStorageBackend = class {
+  storage;
+  constructor(storage) {
+    this.storage = storage;
+  }
+  get(key) {
+    return this.storage.getItem(key);
+  }
+  remove(key) {
+    this.storage.removeItem(key);
+  }
+  set(key, value) {
+    this.storage.setItem(key, value);
+  }
+};
+var pageBackend = new InMemoryBackend();
+var localBackend;
+var sessionBackend;
+function getBackend(area) {
+  if (area === "page") return pageBackend;
+  const g = globalThis;
+  if (area === "local") {
+    if (localBackend) return localBackend;
+    localBackend = g.localStorage ? new WebStorageBackend(g.localStorage) : new InMemoryBackend();
+    return localBackend;
+  }
+  if (sessionBackend) return sessionBackend;
+  sessionBackend = g.sessionStorage ? new WebStorageBackend(g.sessionStorage) : new InMemoryBackend();
+  return sessionBackend;
+}
+var NamespacedStorage = class {
+  backend;
+  prefix;
+  constructor(area, namespace) {
+    this.backend = getBackend(area);
+    this.prefix = `${namespace}.`;
+  }
+  get(key) {
+    const raw = this.backend.get(this.prefix + key);
+    if (raw === null) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  remove(key) {
+    this.backend.remove(this.prefix + key);
+  }
+  set(key, value) {
+    this.backend.set(this.prefix + key, JSON.stringify(value));
+  }
+};
+
+// src/StoragePreviousHashStore.ts
+var StoragePreviousHashStore = class _StoragePreviousHashStore {
+  static DefaultNamespace = "xyo-previous-hash-store";
+  static DefaultStorageType = "local";
+  _namespace = _StoragePreviousHashStore.DefaultNamespace;
+  _storage;
+  _type = _StoragePreviousHashStore.DefaultStorageType;
+  constructor(opts) {
+    if (typeof opts?.namespace === "string") this._namespace = opts.namespace;
+    if (opts?.type) this._type = opts.type;
+    this._storage = new NamespacedStorage(this.type, this.namespace);
+  }
+  get storage() {
+    this._storage ??= new NamespacedStorage(this.type, this.namespace);
+    return this._storage;
+  }
+  get namespace() {
+    return this._namespace;
+  }
+  get type() {
+    return this._type;
+  }
+  async getItem(address) {
+    return this.storage.get(address) ?? null;
+  }
+  async removeItem(address) {
+    this.storage.remove(address);
+  }
+  async setItem(address, previousHash) {
+    this.storage.set(address, previousHash);
+  }
+};
+export {
+  NamespacedStorage,
+  StoragePreviousHashStore
+};

package/dist/_pkg/sdk-protocol/_pkg/protocol/neutral/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../../boundwitness/neutral/index.ts';
+export * from '../../core/neutral/index.ts';
+export * from '../../crypto/neutral/index.ts';
+export * from '../../payload/neutral/index.ts';

package/dist/_pkg/sdk-protocol/_pkg/protocol/neutral/index.mjs

@@ -0,0 +1,5 @@
+// src/index.ts
+export * from "../../boundwitness/neutral/index.mjs";
+export * from "../../core/neutral/index.mjs";
+export * from "../../crypto/neutral/index.mjs";
+export * from "../../payload/neutral/index.mjs";

package/dist/_pkg/sdk-protocol/_pkg/quadkey/neutral/Quadkey.d.ts

@@ -0,0 +1,64 @@
+import type { MercatorBoundingBox, MercatorLngLatLike, MercatorTile } from '@xylabs/geo';
+import { GeoJson, MercatorLngLat } from '@xylabs/geo';
+export declare const isQuadkey: (obj: {
+    type: string;
+}) => boolean;
+export declare class Quadkey {
+    static readonly Zero: Quadkey;
+    static readonly root: Quadkey;
+    static readonly type = "Quadkey";
+    private _geoJson?;
+    key: bigint;
+    type: string;
+    constructor(key?: bigint);
+    static from(zoom: number, id: bigint): Quadkey;
+    static fromArrayBuffer(zoom: number, id: ArrayBuffer): Quadkey;
+    static fromBase16String(value: string): Quadkey;
+    static fromBase4String(value?: string): Quadkey;
+    static fromBoundingBox(boundingBox: MercatorBoundingBox, zoom: number): Quadkey[];
+    static fromLngLat(point: MercatorLngLatLike, zoom: number): Quadkey;
+    static fromString(zoom: number, id: string, base?: number): Quadkey;
+    static fromTile(tile: MercatorTile): Quadkey;
+    get base10String(): string;
+    get base16String(): string;
+    get base4Hash(): string;
+    get base4HashLabel(): string;
+    get boundingBox(): MercatorBoundingBox;
+    get center(): MercatorLngLat;
+    get children(): Quadkey[];
+    get gridLocation(): {
+        col: number;
+        row: number;
+        zoom: number;
+    };
+    get id(): bigint;
+    get parent(): Quadkey | undefined;
+    get siblings(): Quadkey[];
+    get tile(): MercatorTile;
+    get valid(): boolean;
+    get zoom(): number;
+    childrenByZoom(zoom: number): Quadkey[];
+    clone(): Quadkey;
+    equals(obj: Quadkey): boolean;
+    geoJson(): GeoJson;
+    getGridBoundingBox(size: number): {
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+    };
+    /** @deprecated use .gridLocation instead */
+    getGridLocation(): {
+        col: number;
+        row: number;
+        zoom: number;
+    };
+    isInBoundingBox(boundingBox: MercatorBoundingBox): boolean;
+    relative(direction: string): Quadkey;
+    setId(id: bigint): this;
+    setKey(zoom: number, key: bigint): this;
+    setZoom(zoom: number): this;
+    toJSON(): string;
+    toString(): string;
+    protected guessZoom(): void;
+}

package/dist/_pkg/sdk-protocol/_pkg/quadkey/neutral/RelativeDirectionConstantLookup.d.ts

@@ -0,0 +1 @@
+export declare const RelativeDirectionConstantLookup: Record<string, number>;

package/dist/_pkg/sdk-protocol/_pkg/quadkey/neutral/index.d.ts

@@ -0,0 +1 @@
+export * from './Quadkey.ts';