@xyo-network/sdk-protocol 7.0.12 → 7.0.14

package/dist/_pkg/payload-model/neutral/index.mjs

@@ -1,451 +0,0 @@
-// src/Error.ts
-import {
-  HashZod as HashZod2,
-  zodAsFactory as zodAsFactory3,
-  zodIsFactory as zodIsFactory3,
-  zodToFactory as zodToFactory2
-} from "@ariestools/sdk";
-import * as z4 from "zod/mini";
-
-// src/PayloadZod.ts
-import {
-  HashZod,
-  zodAsFactory as zodAsFactory2,
-  zodIsFactory as zodIsFactory2,
-  zodToFactory
-} from "@ariestools/sdk";
-import * as z3 from "zod/mini";
-
-// src/Schema.ts
-import { zodAsFactory, zodIsFactory } from "@ariestools/sdk";
-import * as z from "zod/mini";
-var SchemaRegEx = /^(?:[a-z0-9]+\.)*[a-z0-9]+$/;
-var SchemaZod = z.pipe(z.string().check(z.regex(SchemaRegEx)), z.transform((v) => v));
-var makeSchema = (value) => {
-  return z.pipe(z.literal(value), z.transform((x) => x));
-};
-var isSchema = zodIsFactory(SchemaZod);
-var asSchema = zodAsFactory(SchemaZod, "asSchema");
-var toSchema = zodAsFactory(SchemaZod, "toSchema");
-var PayloadSchema = asSchema("network.xyo.payload", true);
-var PayloadSchemaZod = z.literal(PayloadSchema);
-
-// src/StorageMeta/Sequence.ts
-import { AsObjectFactory } from "@ariestools/sdk";
-var isSequenceStorageMeta = (value) => {
-  return value?._sequence != void 0;
-};
-var asSequenceStorageMeta = AsObjectFactory.create(isSequenceStorageMeta);
-var asOptionalSequenceStorageMeta = AsObjectFactory.createOptional(isSequenceStorageMeta);
-
-// src/StorageMeta/sequence/Parser.ts
-import {
-  assertEx,
-  isAddress,
-  toAddress,
-  toHex,
-  toUint8Array
-} from "@ariestools/sdk";
-
-// src/StorageMeta/sequence/Sequence.ts
-import { isHex } from "@ariestools/sdk";
-var isEpoch = (value) => {
-  return isHex(value) && value.length === SequenceConstants.epochBytes * 2;
-};
-var isNonce = (value) => {
-  return isHex(value) && value.length === SequenceConstants.nonceBytes * 2;
-};
-var isLocalSequence = (value) => {
-  return isHex(value) && value.length === SequenceConstants.localSequenceBytes * 2;
-};
-var isQualifiedSequence = (value) => {
-  return isHex(value) && value.length === SequenceConstants.qualifiedSequenceBytes * 2;
-};
-var isSequence = (value) => {
-  return isLocalSequence(value) || isQualifiedSequence(value);
-};
-var SequenceNonceComponentLengths = {
-  nonceIndexBytes: 4,
-  nonceHashBytes: 4
-};
-var SequenceComponentLengths = {
-  ...SequenceNonceComponentLengths,
-  epochBytes: 8,
-  nonceBytes: SequenceNonceComponentLengths.nonceIndexBytes + SequenceNonceComponentLengths.nonceHashBytes,
-  addressBytes: 20
-};
-var SequenceComponentMinMax = {
-  minEpoch: "0".repeat(SequenceComponentLengths.epochBytes * 2),
-  maxEpoch: "f".repeat(SequenceComponentLengths.epochBytes * 2),
-  minNonce: "0".repeat(SequenceComponentLengths.nonceBytes * 2),
-  maxNonce: "f".repeat(SequenceComponentLengths.nonceBytes * 2),
-  minAddress: "0".repeat(SequenceComponentLengths.addressBytes * 2),
-  maxAddress: "f".repeat(SequenceComponentLengths.addressBytes * 2)
-};
-var LocalSequenceConstants = {
-  ...SequenceComponentLengths,
-  ...SequenceComponentMinMax,
-  localSequenceBytes: SequenceComponentLengths.epochBytes + SequenceComponentLengths.nonceBytes,
-  minLocalSequence: SequenceComponentMinMax.minEpoch + SequenceComponentMinMax.minNonce,
-  maxLocalSequence: SequenceComponentMinMax.maxEpoch + SequenceComponentMinMax.maxNonce
-};
-var QualifiedSequenceConstants = {
-  qualifiedSequenceBytes: LocalSequenceConstants.localSequenceBytes + SequenceComponentLengths.addressBytes,
-  minQualifiedSequence: LocalSequenceConstants.minLocalSequence + SequenceComponentMinMax.minAddress,
-  maxQualifiedSequence: LocalSequenceConstants.maxLocalSequence + SequenceComponentMinMax.maxAddress
-};
-var SequenceConstants = {
-  ...LocalSequenceConstants,
-  ...QualifiedSequenceConstants
-};
-
-// src/StorageMeta/sequence/Parser.ts
-var SequenceParser = class _SequenceParser {
-  static privateConstructorKey = Date.now().toString();
-  data;
-  constructor(privateConstructorKey, hex) {
-    assertEx(_SequenceParser.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
-    const paddedHex = toHex(hex, {
-      prefix: false,
-      bitLength: SequenceConstants[hex.length <= SequenceConstants.localSequenceBytes * 2 ? "localSequenceBytes" : "qualifiedSequenceBytes"] * 8
-    });
-    this.data = toUint8Array(paddedHex);
-  }
-  static from(timestampOrSequence, nonceOrAddress, addressOrIndex, addressOnly) {
-    if (isSequence(timestampOrSequence)) {
-      if (nonceOrAddress) {
-        assertEx(!isQualifiedSequence(timestampOrSequence), () => "Providing both a qualified sequence and a address is not allowed");
-        assertEx(isAddress(nonceOrAddress), () => "Invalid address provided");
-        const combined = timestampOrSequence + nonceOrAddress;
-        return this.create(combined);
-      }
-      return this.create(timestampOrSequence);
-    }
-    const address = typeof addressOrIndex === "number" ? addressOnly : addressOrIndex;
-    const index = typeof addressOrIndex === "number" ? addressOrIndex : void 0;
-    const epoch = this.toEpoch(timestampOrSequence);
-    const nonce = nonceOrAddress === void 0 ? void 0 : this.toNonce(nonceOrAddress, index);
-    const addressHex = address ? toHex(address, { bitLength: SequenceConstants.addressBytes * 8 }) : SequenceConstants.minAddress;
-    const hexString = epoch + nonce + addressHex;
-    assertEx(isSequence(hexString), () => `Invalid sequence [${hexString}] [${epoch}, ${nonce}, ${addressHex}]`);
-    return this.create(hexString);
-  }
-  static parse(value) {
-    const hex = toHex(value);
-    if (isSequence(hex)) {
-      return this.create(hex);
-    }
-    throw new Error(`Invalid sequence [${hex}]`);
-  }
-  // can convert a short number/hex to an epoch (treats it as the whole value) or extract an epoch from a sequence
-  static toEpoch(value) {
-    assertEx(
-      typeof value !== "number" || Number.isSafeInteger(value),
-      () => "Value must be in integer"
-    );
-    const hex = toHex(value, { prefix: false });
-    if (hex.length <= SequenceConstants.epochBytes * 2) {
-      return toHex(value, { prefix: false, bitLength: SequenceConstants.epochBytes * 8 });
-    }
-    if (isSequence(hex)) {
-      return hex.slice(0, SequenceConstants.epochBytes * 2);
-    }
-    throw new Error(`Value could not be converted to epoch [${hex}]`);
-  }
-  // can convert a short number/hex to a nonce (treats it as the whole value) or extract an nonce from a sequence
-  static toNonce(value, index = 0) {
-    assertEx(
-      typeof value !== "number" || Number.isSafeInteger(value),
-      () => "Value must be in integer"
-    );
-    const hex = toHex(value, { prefix: false });
-    if (isSequence(hex)) {
-      return hex.slice(SequenceConstants.epochBytes * 2, SequenceConstants.localSequenceBytes * 2);
-    }
-    const hashHex = toHex(hex, { prefix: false, bitLength: SequenceConstants.nonceHashBytes * 8 }).slice(-SequenceConstants.nonceHashBytes * 2);
-    const indexHex = toHex(index, { prefix: false, bitLength: SequenceConstants.nonceIndexBytes * 8 }).slice(-SequenceConstants.nonceIndexBytes * 2);
-    return (indexHex + hashHex).slice(-SequenceConstants.nonceBytes * 2);
-  }
-  static create(hex) {
-    return new _SequenceParser(this.privateConstructorKey, hex);
-  }
-  get address() {
-    const start = SequenceConstants.localSequenceBytes;
-    const end = SequenceConstants.qualifiedSequenceBytes;
-    return toAddress(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  get epoch() {
-    const start = 0;
-    const end = SequenceConstants.epochBytes;
-    return toHex(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  get localSequence() {
-    const start = 0;
-    const end = SequenceConstants.localSequenceBytes;
-    return toHex(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  get nonce() {
-    const start = SequenceConstants.epochBytes;
-    const end = SequenceConstants.localSequenceBytes;
-    return toHex(this.data.slice(start, end).buffer, { prefix: false });
-  }
-  get qualifiedSequence() {
-    const start = 0;
-    const end = SequenceConstants.qualifiedSequenceBytes;
-    return toHex(this.data.slice(start, end).buffer, { prefix: false });
-  }
-};
-
-// src/StorageMeta/sequence/Comparer.ts
-var local = (a, b) => {
-  const aa = SequenceParser.from(a);
-  const bb = SequenceParser.from(b);
-  return aa.localSequence > bb.localSequence ? 1 : aa.localSequence < bb.localSequence ? -1 : 0;
-};
-var qualified = (a, b) => {
-  const aa = SequenceParser.from(a);
-  const bb = SequenceParser.from(b);
-  return aa.qualifiedSequence > bb.qualifiedSequence ? 1 : aa.qualifiedSequence < bb.qualifiedSequence ? -1 : 0;
-};
-var SequenceComparer = { local, qualified };
-
-// src/StorageMeta/sequence/SequenceZod.ts
-import { HexRegExMinMax, toHex as toHex2 } from "@ariestools/sdk";
-import * as z2 from "zod/mini";
-var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
-var LocalSequenceToStringZod = z2.string().check(z2.regex(LocalSequenceRegex));
-var LocalSequenceFromStringZod = z2.pipe(
-  z2.string().check(z2.regex(LocalSequenceRegex)),
-  z2.transform((v) => toHex2(v))
-);
-var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
-var QualifiedSequenceToStringZod = z2.string().check(z2.regex(QualifiedSequenceRegex));
-var QualifiedSequenceFromStringZod = z2.pipe(
-  z2.string().check(z2.regex(QualifiedSequenceRegex)),
-  z2.transform((v) => toHex2(v))
-);
-var SequenceToStringZod = z2.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod]);
-var SequenceFromStringZod = z2.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod]);
-
-// src/PayloadZod.ts
-var HashMetaZod = z3.object({
-  _hash: HashZod,
-  _dataHash: HashZod
-});
-var isHashMeta = zodIsFactory2(HashMetaZod);
-var asHashMeta = zodAsFactory2(HashMetaZod, "asHashMeta");
-var toHashMeta = zodToFactory(HashMetaZod, "toHashMeta");
-var SequenceMetaZod = z3.object({ _sequence: SequenceFromStringZod });
-var isSequenceMeta = zodIsFactory2(SequenceMetaZod);
-var asSequenceMeta = zodAsFactory2(SequenceMetaZod, "asSequenceMeta");
-var toSequenceMeta = zodToFactory(SequenceMetaZod, "toSequenceMeta");
-var StorageMetaZod = z3.object({
-  _hash: HashZod,
-  _dataHash: HashZod,
-  _sequence: SequenceFromStringZod
-});
-var isStorageMeta = zodIsFactory2(StorageMetaZod);
-var asStorageMeta = zodAsFactory2(StorageMetaZod, "asStorageMeta");
-var toStorageMeta = zodToFactory(StorageMetaZod, "toStorageMeta");
-var PayloadZod = z3.object({ schema: SchemaZod });
-var isPayload = zodIsFactory2(PayloadZod);
-var asPayload = zodAsFactory2(PayloadZod, "asPayload");
-var toPayload = zodToFactory(PayloadZod, "toPayload");
-var AnyPayloadZod = z3.looseObject({ schema: SchemaZod });
-var isAnyPayload = zodIsFactory2(AnyPayloadZod);
-var asAnyPayload = zodAsFactory2(AnyPayloadZod, "asAnyPayload");
-var toAnyPayload = zodToFactory(AnyPayloadZod, "toAnyPayload");
-function WithStorageMetaZod(valueZod) {
-  return z3.object({ ...valueZod.shape, ...StorageMetaZod.shape });
-}
-function WithHashMetaZod(valueZod) {
-  return z3.object({ ...valueZod.shape, ...HashMetaZod.shape });
-}
-var PayloadZodStrict = z3.strictObject({ schema: SchemaZod });
-var PayloadZodLoose = z3.looseObject({ schema: SchemaZod });
-var WithHashMetaPayloadZodLoose = z3.extend(PayloadZodLoose, HashMetaZod.shape);
-var PayloadZodOfSchema = (schema) => z3.extend(PayloadZod, { schema: z3.literal(schema) });
-var PayloadZodStrictOfSchema = (schema) => z3.extend(PayloadZodStrict, { schema: z3.literal(schema) });
-var PayloadZodLooseOfSchema = (schema) => z3.extend(PayloadZodLoose, { schema: z3.literal(schema) });
-
-// src/Error.ts
-var ModuleErrorSchema = asSchema("network.xyo.error.module", true);
-var ModuleErrorZod = z4.extend(PayloadZodOfSchema(ModuleErrorSchema), {
-  details: z4.optional(z4.custom()),
-  message: z4.optional(z4.string()),
-  name: z4.optional(z4.string()),
-  query: z4.optional(z4.union([HashZod2, SchemaZod]))
-});
-var isModuleError = zodIsFactory3(ModuleErrorZod);
-var asModuleError = zodAsFactory3(ModuleErrorZod, "asModuleError");
-var toModuleError = zodToFactory2(ModuleErrorZod, "toModuleError");
-
-// src/isPayloadOfSchemaType.ts
-function isPayloadOfSchemaType(schema) {
-  return (x) => isAnyPayload(x) && x?.schema === schema;
-}
-var isPayloadOfSchemaTypeWithSources = (schema) => {
-  return (x) => isPayloadOfSchemaType(schema)(x) && x.$sources != void 0 && Array.isArray(x.$sources);
-};
-var notPayloadOfSchemaType = (schema) => {
-  return (x) => !isAnyPayload(x) || x?.schema !== schema;
-};
-
-// src/isPayloadOfZodType.ts
-import { isDefined } from "@ariestools/sdk";
-import * as z5 from "zod/mini";
-function isPayloadOfZodType(zodSchema, schema) {
-  return (x) => {
-    if (!isAnyPayload(x)) return false;
-    if (isDefined(schema) && x.schema !== schema) return false;
-    const { schema: _, ...data } = x;
-    return z5.safeParse(zodSchema, data).success;
-  };
-}
-
-// src/PayloadBundle.ts
-import {
-  HashZod as HashZod3,
-  zodAsFactory as zodAsFactory4,
-  zodIsFactory as zodIsFactory4,
-  zodToFactory as zodToFactory3
-} from "@ariestools/sdk";
-import * as z6 from "zod/mini";
-var PayloadBundleSchema = asSchema("network.xyo.payload.bundle", true);
-var PayloadBundleFieldsZod = z6.object({
-  payloads: z6.array(PayloadZodLoose),
-  root: HashZod3
-});
-var PayloadBundleZod = z6.extend(PayloadZodOfSchema(PayloadBundleSchema), PayloadBundleFieldsZod.shape);
-var isPayloadBundle = zodIsFactory4(PayloadBundleZod);
-var asPayloadBundle = zodAsFactory4(PayloadBundleZod, "asPayloadBundle");
-var asOptionalPayloadBundle = zodToFactory3(PayloadBundleZod, "asPayloadBundle");
-
-// src/PayloadSet/PayloadSetPayload.ts
-import {
-  zodAsFactory as zodAsFactory5,
-  zodIsFactory as zodIsFactory5,
-  zodToFactory as zodToFactory4
-} from "@ariestools/sdk";
-import * as z7 from "zod/mini";
-
-// src/PayloadSet/PayloadSetSchema.ts
-var PayloadSetSchema = asSchema("network.xyo.payload.set", true);
-
-// src/PayloadSet/PayloadSetPayload.ts
-var stringNumberRecordZod = z7.record(z7.string(), z7.number());
-var PayloadSetZod = z7.object({
-  optional: z7.optional(stringNumberRecordZod),
-  required: z7.optional(stringNumberRecordZod)
-});
-var PayloadSetPayloadZod = z7.extend(PayloadZodOfSchema(PayloadSetSchema), PayloadSetZod.shape);
-var isPayloadSetPayload = zodIsFactory5(PayloadSetPayloadZod);
-var asPayloadSetPayload = zodAsFactory5(PayloadSetPayloadZod, "asPayloadSetPayload");
-var toPayloadSetPayload = zodToFactory4(PayloadSetPayloadZod, "toPayloadSetPayload");
-
-// src/Query.ts
-import { XyoAddressZod } from "../../address/neutral/index.mjs";
-import * as z8 from "zod/mini";
-var queryAddressZod = z8.union([XyoAddressZod, z8.array(XyoAddressZod)]);
-var maxFrequencyZod = z8.union([
-  z8.literal("once"),
-  z8.literal("second"),
-  z8.literal("minute"),
-  z8.literal("hour"),
-  z8.literal("day"),
-  z8.literal("week"),
-  z8.literal("month"),
-  z8.literal("year")
-]);
-var QueryFieldsZod = z8.object({
-  /** @field The addresses of the intended handlers */
-  address: z8.optional(queryAddressZod),
-  /** @field The maximum XYO that can be spent executing the query */
-  budget: z8.optional(z8.number()),
-  /** @field The frequency on which this query can be rerun */
-  maxFrequency: z8.optional(maxFrequencyZod),
-  /** @field The starting point for the bidding on the query */
-  minBid: z8.optional(z8.number())
-});
-export {
-  AnyPayloadZod,
-  HashMetaZod,
-  LocalSequenceConstants,
-  LocalSequenceFromStringZod,
-  LocalSequenceToStringZod,
-  ModuleErrorSchema,
-  ModuleErrorZod,
-  PayloadBundleFieldsZod,
-  PayloadBundleSchema,
-  PayloadBundleZod,
-  PayloadSchema,
-  PayloadSchemaZod,
-  PayloadSetPayloadZod,
-  PayloadSetSchema,
-  PayloadSetZod,
-  PayloadZod,
-  PayloadZodLoose,
-  PayloadZodLooseOfSchema,
-  PayloadZodOfSchema,
-  PayloadZodStrict,
-  PayloadZodStrictOfSchema,
-  QualifiedSequenceConstants,
-  QualifiedSequenceFromStringZod,
-  QualifiedSequenceToStringZod,
-  QueryFieldsZod,
-  SchemaRegEx,
-  SchemaZod,
-  SequenceComparer,
-  SequenceComponentLengths,
-  SequenceComponentMinMax,
-  SequenceConstants,
-  SequenceFromStringZod,
-  SequenceMetaZod,
-  SequenceNonceComponentLengths,
-  SequenceParser,
-  SequenceToStringZod,
-  StorageMetaZod,
-  WithHashMetaPayloadZodLoose,
-  WithHashMetaZod,
-  WithStorageMetaZod,
-  asAnyPayload,
-  asHashMeta,
-  asModuleError,
-  asOptionalPayloadBundle,
-  asOptionalSequenceStorageMeta,
-  asPayload,
-  asPayloadBundle,
-  asPayloadSetPayload,
-  asSchema,
-  asSequenceMeta,
-  asSequenceStorageMeta,
-  asStorageMeta,
-  isAnyPayload,
-  isEpoch,
-  isHashMeta,
-  isLocalSequence,
-  isModuleError,
-  isNonce,
-  isPayload,
-  isPayloadBundle,
-  isPayloadOfSchemaType,
-  isPayloadOfSchemaTypeWithSources,
-  isPayloadOfZodType,
-  isPayloadSetPayload,
-  isQualifiedSequence,
-  isSchema,
-  isSequence,
-  isSequenceMeta,
-  isSequenceStorageMeta,
-  isStorageMeta,
-  makeSchema,
-  notPayloadOfSchemaType,
-  toAnyPayload,
-  toHashMeta,
-  toModuleError,
-  toPayload,
-  toPayloadSetPayload,
-  toSchema,
-  toSequenceMeta,
-  toStorageMeta
-};

package/dist/_pkg/payload-model/neutral/isPayloadOfSchemaType.d.ts

@@ -1,4 +0,0 @@
-import type { Payload, WithSources } from './Payload.ts';
-export declare function isPayloadOfSchemaType<T extends Payload = never>(schema: T['schema']): (x?: unknown) => x is T;
-export declare const isPayloadOfSchemaTypeWithSources: <T extends Payload = never>(schema: T["schema"]) => (x?: unknown) => x is WithSources<T>;
-export declare const notPayloadOfSchemaType: <T extends Payload = never>(schema: T["schema"]) => (x?: unknown) => x is T;

package/dist/_pkg/payload-model/neutral/isPayloadOfZodType.d.ts

@@ -1,11 +0,0 @@
-import * as z from 'zod/mini';
-import type { Payload } from './Payload.ts';
-/**
- * Checks if a value is a payload of a specific Zod type.
- * @param zodSchema The Zod schema to validate against
- * @param schema The schema string to match against the payload. Optional in
- * case you want to validate any payload matching the Zod schema or in case
- * schema is part of the Zod schema.
- * @returns A function that checks if a value is a payload of the specified Zod type
- */
-export declare function isPayloadOfZodType<T extends Payload = never, S extends z.core.$ZodObject = z.core.$ZodObject>(zodSchema: S, schema?: T['schema']): (x?: unknown) => x is T;

package/dist/_pkg/payload-model/node/Error.d.ts

@@ -1,64 +0,0 @@
-import * as z from 'zod/mini';
-export declare const ModuleErrorSchema: "network.xyo.error.module" & {
-    readonly __schema: true;
-};
-export type ModuleErrorSchema = typeof ModuleErrorSchema;
-export declare const ModuleErrorZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<"network.xyo.error.module" & {
-        readonly __schema: true;
-    }>;
-    details: z.ZodMiniOptional<z.ZodMiniCustom<unknown, unknown>>;
-    message: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    query: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>]>>;
-}, z.core.$strip>;
-export type ModuleError = z.infer<typeof ModuleErrorZod>;
-export declare const isModuleError: <T>(value: T) => value is T & {
-    schema: "network.xyo.error.module" & {
-        readonly __schema: true;
-    };
-    details?: unknown;
-    message?: string | undefined;
-    name?: string | undefined;
-    query?: import("./Schema.ts").BrandedSchema<string> | import("@ariestools/sdk").BrandedHash | undefined;
-};
-export declare const asModuleError: {
-    <T>(value: T): (T & {
-        schema: "network.xyo.error.module" & {
-            readonly __schema: true;
-        };
-        details?: unknown;
-        message?: string | undefined;
-        name?: string | undefined;
-        query?: import("./Schema.ts").BrandedSchema<string> | import("@ariestools/sdk").BrandedHash | undefined;
-    }) | undefined;
-    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
-        schema: "network.xyo.error.module" & {
-            readonly __schema: true;
-        };
-        details?: unknown;
-        message?: string | undefined;
-        name?: string | undefined;
-        query?: import("./Schema.ts").BrandedSchema<string> | import("@ariestools/sdk").BrandedHash | undefined;
-    };
-};
-export declare const toModuleError: {
-    <T>(value: T): (T & {
-        schema: "network.xyo.error.module" & {
-            readonly __schema: true;
-        };
-        details?: unknown;
-        message?: string | undefined;
-        name?: string | undefined;
-        query?: import("./Schema.ts").BrandedSchema<string> | import("@ariestools/sdk").BrandedHash | undefined;
-    }) | undefined;
-    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
-        schema: "network.xyo.error.module" & {
-            readonly __schema: true;
-        };
-        details?: unknown;
-        message?: string | undefined;
-        name?: string | undefined;
-        query?: import("./Schema.ts").BrandedSchema<string> | import("@ariestools/sdk").BrandedHash | undefined;
-    };
-};

package/dist/_pkg/payload-model/node/Payload.d.ts

@@ -1,34 +0,0 @@
-import type { DeepOmitStartsWith, DeepPickStartsWith, EmptyObject, Hash } from '@ariestools/sdk';
-import type { BrandedSchema, Schema } from './Schema.ts';
-export interface SchemaField<T extends Schema = Schema> {
-    schema: T;
-}
-export type WithSchema<T extends EmptyObject | void = void> = T extends EmptyObject ? SchemaField & T : PayloadFields;
-/** Additional fields for a payload */
-export interface PayloadFields extends SchemaField {
-}
-export interface SourcesMetaField {
-    $sources: Hash[];
-}
-export interface PayloadMetaFields extends SourcesMetaField {
-}
-export type WithPayload<T extends EmptyObject | void = void> = T extends EmptyObject ? PayloadFields & T : PayloadFields;
-/** Base Type for Payloads */
-export type Payload<T extends void | EmptyObject | SchemaField = void, S extends Schema | void = void> = (T extends SchemaField ? S extends Schema ? WithPayload<Omit<T, 'schema'> & {
-    schema: BrandedSchema<S>;
-}> : WithPayload<T> : T extends object ? S extends Schema ? WithPayload<T & {
-    schema: BrandedSchema<S>;
-}> : WithPayload<T & PayloadFields> : WithPayload<{
-    schema: S extends Schema ? S : Schema;
-}>) & Partial<PayloadMetaFields>;
-export type OverridablePayload<T extends Payload> = WithoutMeta<Omit<T, 'schema'> & PayloadFields>;
-export type WithSources<T extends EmptyObject> = T & SourcesMetaField;
-export type PayloadWithSources<T extends void | EmptyObject | SchemaField = void, S extends Schema | void = void> = WithSources<Payload<T, S>>;
-export type WithAnySchema<T extends Payload> = OverridablePayload<T>;
-export type WithoutClientMeta<T extends Payload | EmptyObject> = DeepOmitStartsWith<T, '$'> & (T extends Payload ? Payload : EmptyObject);
-export type WithoutStorageMeta<T extends Payload | EmptyObject> = DeepOmitStartsWith<T, '_'> & (T extends Payload ? Payload : EmptyObject);
-export type WithoutPrivateStorageMeta<T extends Payload | EmptyObject> = DeepOmitStartsWith<T, '__'> & (T extends Payload ? Payload : EmptyObject);
-export type WithoutMeta<T extends Payload | EmptyObject> = WithoutClientMeta<WithoutStorageMeta<T>> & (T extends Payload ? Payload : EmptyObject);
-export type WithoutSchema<T extends WithOptionalSchema<Payload>> = Omit<T, 'schema'>;
-export type WithOptionalSchema<T extends Payload = Payload> = WithoutSchema<T> & Partial<T & SchemaField>;
-export type WithOnlyClientMeta<T extends Payload> = DeepPickStartsWith<T, '$'>;

package/dist/_pkg/payload-model/node/PayloadBundle.d.ts

@@ -1,71 +0,0 @@
-import * as z from 'zod/mini';
-export declare const PayloadBundleSchema: "network.xyo.payload.bundle" & {
-    readonly __schema: true;
-};
-export type PayloadBundleSchema = typeof PayloadBundleSchema;
-export declare const PayloadBundleFieldsZod: z.ZodMiniObject<{
-    payloads: z.ZodMiniArray<z.ZodMiniObject<{
-        schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>;
-    }, z.core.$strict>>;
-    root: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
-}, z.core.$strip>;
-export type PayloadBundleFields = z.infer<typeof PayloadBundleFieldsZod>;
-export declare const PayloadBundleZod: z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<"network.xyo.payload.bundle" & {
-        readonly __schema: true;
-    }>;
-    payloads: z.ZodMiniArray<z.ZodMiniObject<{
-        schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>;
-    }, z.core.$strict>>;
-    root: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
-}, z.core.$strip>;
-export type PayloadBundle = z.infer<typeof PayloadBundleZod>;
-export declare const isPayloadBundle: <T>(value: T) => value is T & {
-    schema: "network.xyo.payload.bundle" & {
-        readonly __schema: true;
-    };
-    payloads: {
-        schema: import("./Schema.ts").BrandedSchema<string>;
-    }[];
-    root: import("@ariestools/sdk").BrandedHash;
-};
-export declare const asPayloadBundle: {
-    <T>(value: T): (T & {
-        schema: "network.xyo.payload.bundle" & {
-            readonly __schema: true;
-        };
-        payloads: {
-            schema: import("./Schema.ts").BrandedSchema<string>;
-        }[];
-        root: import("@ariestools/sdk").BrandedHash;
-    }) | undefined;
-    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
-        schema: "network.xyo.payload.bundle" & {
-            readonly __schema: true;
-        };
-        payloads: {
-            schema: import("./Schema.ts").BrandedSchema<string>;
-        }[];
-        root: import("@ariestools/sdk").BrandedHash;
-    };
-};
-export declare const asOptionalPayloadBundle: {
-    <T>(value: T): (T & {
-        schema: "network.xyo.payload.bundle" & {
-            readonly __schema: true;
-        };
-        payloads: {
-            schema: import("./Schema.ts").BrandedSchema<string>;
-        }[];
-        root: import("@ariestools/sdk").BrandedHash;
-    }) | undefined;
-    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
-        schema: "network.xyo.payload.bundle" & {
-            readonly __schema: true;
-        };
-        payloads: {
-            schema: import("./Schema.ts").BrandedSchema<string>;
-        }[];
-        root: import("@ariestools/sdk").BrandedHash;
-    };
-};

package/dist/_pkg/payload-model/node/PayloadFindFilter.d.ts

@@ -1,5 +0,0 @@
-export interface PayloadFindFilter {
-    limit?: number;
-    order?: 'desc' | 'asc';
-    schema?: string | string[];
-}

package/dist/_pkg/payload-model/node/PayloadHashMap.d.ts

@@ -1,6 +0,0 @@
-import type { Hash } from '@ariestools/sdk';
-import type { Payload } from './Payload.ts';
-export interface PayloadHashMap<TPayload extends Payload = Payload, TId extends string | number | symbol = Hash> {
-    dataHash: Record<TId, TId>;
-    hash: Record<TId, TPayload>;
-}