@xyo-network/sdk 2.102.3 → 7.0.2

package/dist/_pkg/payload-builder/neutral/Builder.d.ts

@@ -0,0 +1,69 @@
+import type { AnyObject, Compare, EmptyObject, Hash, Promisable } from '@xylabs/sdk';
+import type { Payload, Schema, Sequence, WithHashMeta, WithOnlyClientMeta, WithOptionalSchema, WithoutClientMeta, WithoutMeta, WithoutPrivateStorageMeta, WithoutSchema, WithoutStorageMeta, WithStorageMeta } from '../../payload-model/neutral/index.ts';
+import type { PayloadBuilderOptions } from './Options.ts';
+export declare const omitSchema: <T extends WithOptionalSchema>(payload: T) => WithoutSchema<T>;
+export declare class PayloadBuilder<T extends Payload = Payload<AnyObject>, R = T> {
+    readonly options: PayloadBuilderOptions;
+    protected _fields?: WithoutStorageMeta<WithoutClientMeta<WithoutSchema<T>>>;
+    protected _meta?: WithOnlyClientMeta<T>;
+    protected _schema: Schema;
+    constructor(options: PayloadBuilderOptions);
+    static addHashMeta<T extends Payload>(payload: T): Promise<WithHashMeta<T>>;
+    static addHashMeta<T extends Payload>(payloads: T[]): Promise<WithHashMeta<T>[]>;
+    static addStorageMeta<T extends Payload>(payload: T, index?: number): Promise<WithStorageMeta<T>>;
+    static addStorageMeta<T extends Payload>(payloads: T[]): Promise<WithStorageMeta<T>[]>;
+    static compareStorageMeta(this: void, a: WithStorageMeta<Payload>, b: WithStorageMeta<Payload>, comparer?: Compare<Sequence>): number;
+    static dataHash<T extends Payload>(payload: T): Promise<Hash>;
+    static dataHashPairs<T extends Payload>(payloads: T[]): Promise<[T, Hash][]>;
+    static dataHashableFields<T extends Payload>(schema: Schema, payload: WithoutSchema<T>): Promisable<WithoutMeta<T>>;
+    static dataHashes(payloads: undefined): Promise<undefined>;
+    static dataHashes<T extends Payload>(payloads: T[]): Promise<Hash[]>;
+    static filterExclude<T extends Payload>(payloads: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
+    static filterExcludeByDataHash<T extends Payload>(payloads: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
+    static filterIncludeByDataHash<T extends Payload>(payloads: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
+    static filterIncludeByEitherHash<T extends Payload>(payloads: T[] | undefined, hash: Hash[] | Hash): Promise<T[]>;
+    static findByDataHash<T extends Payload>(payloads: T[] | undefined, hash: Hash): Promise<T | undefined>;
+    static hash<T extends Payload>(payload: T): Promise<Hash>;
+    /**
+     * Creates an array of payload/hash tuples based on the payloads passed in
+     * @param objs Any array of payloads
+     * @returns An array of payload/hash tuples
+     */
+    static hashPairs<T extends Payload>(payloads: T[]): Promise<[T, Hash][]>;
+    static hashableFields<T extends Payload>(payload: T): WithoutStorageMeta<T>;
+    static hashes(payloads: undefined): Promise<undefined>;
+    static hashes<T extends Payload>(payloads: T[]): Promise<Hash[]>;
+    static omitClientMeta<T extends Payload>(payloads: T[], maxDepth?: number): WithoutClientMeta<T>[];
+    static omitClientMeta<T extends EmptyObject>(payloads: T[], maxDepth?: number): WithoutClientMeta<T>[];
+    static omitClientMeta<T extends Payload>(payload: T, maxDepth?: number): WithoutClientMeta<T>;
+    static omitClientMeta<T extends EmptyObject>(payload: T, maxDepth?: number): WithoutClientMeta<T>;
+    static omitMeta<T extends Payload>(payloads: T[], maxDepth?: number): WithoutMeta<T>[];
+    static omitMeta<T extends EmptyObject>(payloads: T[], maxDepth?: number): WithoutMeta<T>[];
+    static omitMeta<T extends Payload>(payload: T, maxDepth?: number): WithoutMeta<T>;
+    static omitMeta<T extends EmptyObject>(payload: T, maxDepth?: number): WithoutMeta<T>;
+    static omitPrivateStorageMeta<T extends Payload>(payloads: T[], maxDepth?: number): WithoutPrivateStorageMeta<T>[];
+    static omitPrivateStorageMeta<T extends EmptyObject>(payloads: T[], maxDepth?: number): WithoutPrivateStorageMeta<T>[];
+    static omitPrivateStorageMeta<T extends Payload>(payload: T, maxDepth?: number): WithoutPrivateStorageMeta<T>;
+    static omitPrivateStorageMeta<T extends EmptyObject>(payload: T, maxDepth?: number): WithoutPrivateStorageMeta<T>;
+    static omitStorageMeta<T extends EmptyObject[]>(payloads: T, maxDepth?: number): WithoutStorageMeta<T[number]>[];
+    static omitStorageMeta<T extends Payload[]>(payloads: T, maxDepth?: number): WithoutStorageMeta<T[number]>[];
+    static omitStorageMeta<T extends EmptyObject>(payload: T, maxDepth?: number): WithoutStorageMeta<T>;
+    static omitStorageMeta<T extends Payload>(payload: T, maxDepth?: number): WithoutStorageMeta<T>;
+    static pickClientMeta<T extends Payload>(payloads: T[], maxDepth?: number): WithOnlyClientMeta<T>[];
+    static pickClientMeta<T extends Payload>(payload: T, maxDepth?: number): WithOnlyClientMeta<T>;
+    static sortByStorageMeta<T extends Payload>(payloads: WithStorageMeta<T>[], direction?: -1 | 1, comparer?: Compare<Sequence>): WithStorageMeta<T>[];
+    static toAllHashMap<T extends Payload>(payloads: T[]): Promise<Record<Hash, T>>;
+    static toDataHashMap<T extends Payload>(objs: T[]): Promise<Record<Hash, T>>;
+    /**
+     * Creates an object map of payload hashes to payloads based on the payloads passed in
+     * @param objs Any array of payloads
+     * @returns A map of hashes to payloads
+     */
+    static toHashMap<T extends Payload>(objs: T[]): Promise<Record<Hash, T>>;
+    private static addSequencedStorageMeta;
+    build(): R;
+    dataHashableFields(): Promise<WithoutMeta<T>>;
+    fields(fields: WithoutSchema<WithoutStorageMeta<WithoutClientMeta<T>>>): this;
+    meta(meta: WithOnlyClientMeta<T>): this;
+    schema(value: Schema): void;
+}

package/dist/_pkg/payload-builder/neutral/Options.d.ts

@@ -0,0 +1,6 @@
+import type { Logger } from '@xylabs/sdk';
+import type { Schema } from '../../payload-model/neutral/index.ts';
+export interface PayloadBuilderOptions {
+    readonly logger?: Logger;
+    readonly schema: Schema;
+}

package/dist/_pkg/payload-builder/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Builder.ts';
+export * from './Options.ts';

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

@@ -0,0 +1,217 @@
+// src/Builder.ts
+import {
+  assertEx,
+  exists,
+  isJsonObject,
+  omitByPrefix,
+  pickByPrefix,
+  toSafeJson
+} from "@xylabs/sdk";
+import { ObjectHasher, removeEmptyFields } from "../../hash/neutral/index-browser.mjs";
+import {
+  SequenceComparer,
+  SequenceParser
+} from "../../payload-model/neutral/index.mjs";
+var omitSchema = (payload) => {
+  const result = structuredClone(payload);
+  delete result.schema;
+  return result;
+};
+var PayloadBuilder = class _PayloadBuilder {
+  options;
+  _fields;
+  _meta;
+  _schema;
+  constructor(options) {
+    this.options = options;
+    const { schema } = options;
+    this._schema = schema;
+  }
+  static async addHashMeta(payloads) {
+    if (Array.isArray(payloads)) {
+      return await Promise.all(
+        payloads.map(async (payload) => {
+          return await this.addHashMeta(payload);
+        })
+      );
+    }
+    const _hash = await this.hash(payloads);
+    const _dataHash = await this.dataHash(payloads);
+    return {
+      ...payloads,
+      _dataHash,
+      _hash
+    };
+  }
+  static async addStorageMeta(payloads, index = 0) {
+    return Array.isArray(payloads) ? await (async () => {
+      const timestamp = Date.now();
+      const sequencedPayloads = await Promise.all(payloads.map(async (payload, i) => await this.addSequencedStorageMeta(
+        payload,
+        timestamp,
+        i
+      )));
+      return sequencedPayloads.toSorted(this.compareStorageMeta);
+    })() : this.addSequencedStorageMeta(
+      payloads,
+      index
+    );
+  }
+  static compareStorageMeta(a, b, comparer = SequenceComparer.local) {
+    return comparer(a._sequence, b._sequence);
+  }
+  static async dataHash(payload) {
+    return await ObjectHasher.hash(this.omitMeta(payload));
+  }
+  static async dataHashPairs(payloads) {
+    return await Promise.all(
+      payloads.map(async (payload) => {
+        const dataHash = await this.dataHash(payload);
+        return [payload, dataHash];
+      })
+    );
+  }
+  static dataHashableFields(schema, payload) {
+    const cleanFields = removeEmptyFields({ ...payload, schema });
+    assertEx(
+      cleanFields == void 0 || isJsonObject(cleanFields),
+      () => `Fields must be JsonObject: ${JSON.stringify(toSafeJson(cleanFields), null, 2)}`
+    );
+    return this.omitMeta(cleanFields);
+  }
+  static async dataHashes(payloads) {
+    return payloads ? await Promise.all(
+      payloads.map(async (payload) => {
+        return await this.dataHash(payload);
+      })
+    ) : void 0;
+  }
+  static async filterExclude(payloads = [], hash) {
+    return await ObjectHasher.filterExcludeByHash(await this.filterExcludeByDataHash(payloads, hash), hash);
+  }
+  static async filterExcludeByDataHash(payloads = [], hash) {
+    const hashes = Array.isArray(hash) ? hash : [hash];
+    const pairs = await this.dataHashPairs(payloads);
+    return pairs.filter(([_, objHash]) => !hashes.includes(objHash))?.map((pair) => pair[0]);
+  }
+  static async filterIncludeByDataHash(payloads = [], hash) {
+    const hashes = Array.isArray(hash) ? hash : [hash];
+    const pairs = await this.dataHashPairs(payloads);
+    return pairs.filter(([_, objHash]) => hashes.includes(objHash))?.map((pair) => pair[0]);
+  }
+  static async filterIncludeByEitherHash(payloads = [], hash) {
+    const hashes = Array.isArray(hash) ? hash : [hash];
+    const map = await this.toAllHashMap(payloads);
+    return hashes.map((hash2) => map[String(hash2)]).filter(exists);
+  }
+  static async findByDataHash(payloads = [], hash) {
+    const pairs = await this.dataHashPairs(payloads);
+    return pairs.find(([_, objHash]) => objHash === hash)?.[0];
+  }
+  static async hash(payload) {
+    return await ObjectHasher.hash(this.omitStorageMeta(payload));
+  }
+  /**
+   * Creates an array of payload/hash tuples based on the payloads passed in
+   * @param objs Any array of payloads
+   * @returns An array of payload/hash tuples
+   */
+  static async hashPairs(payloads) {
+    return await Promise.all(
+      payloads.map(async (payload) => {
+        return [payload, await this.hash(payload)];
+      })
+    );
+  }
+  static hashableFields(payload) {
+    return this.omitStorageMeta(payload);
+  }
+  static async hashes(payloads) {
+    return await ObjectHasher.hashes(payloads);
+  }
+  static omitClientMeta(payloads, maxDepth = 1) {
+    return Array.isArray(payloads) ? payloads.map((payload) => this.omitClientMeta(payload, maxDepth)) : omitByPrefix(payloads, "$", maxDepth);
+  }
+  static omitMeta(payloads, maxDepth = 1) {
+    return Array.isArray(payloads) ? payloads.map((payload) => this.omitMeta(payload, maxDepth)) : this.omitStorageMeta(this.omitClientMeta(payloads, maxDepth), maxDepth);
+  }
+  static omitPrivateStorageMeta(payloads, maxDepth = 1) {
+    return Array.isArray(payloads) ? payloads.map((payload) => this.omitPrivateStorageMeta(payload, maxDepth)) : omitByPrefix(payloads, "__", maxDepth);
+  }
+  static omitStorageMeta(payloads, maxDepth = 1) {
+    return Array.isArray(payloads) ? payloads.map((payload) => this.omitStorageMeta(payload, maxDepth)) : omitByPrefix(payloads, "_", maxDepth);
+  }
+  static pickClientMeta(payloads, maxDepth = 1) {
+    return Array.isArray(payloads) ? payloads.map((payload) => this.pickClientMeta(payload, maxDepth)) : pickByPrefix(payloads, "$", maxDepth);
+  }
+  static sortByStorageMeta(payloads, direction = 1, comparer = SequenceComparer.local) {
+    return payloads.toSorted((a, b) => direction * comparer(a._sequence, b._sequence));
+  }
+  static async toAllHashMap(payloads) {
+    const pairs = await this.hashPairs(payloads);
+    const entries = await Promise.all(
+      pairs.map(async ([payload, payloadHash]) => {
+        const dataHash = await this.dataHash(payload);
+        return [
+          [payloadHash, payload],
+          [dataHash, payload]
+        ];
+      })
+    );
+    return Object.fromEntries(entries.flat());
+  }
+  static async toDataHashMap(objs) {
+    const pairs = await this.dataHashPairs(objs);
+    return Object.fromEntries(pairs.map(([payload, dataHash]) => [dataHash, payload]));
+  }
+  /**
+   * Creates an object map of payload hashes to payloads based on the payloads passed in
+   * @param objs Any array of payloads
+   * @returns A map of hashes to payloads
+   */
+  static async toHashMap(objs) {
+    const pairs = await this.hashPairs(objs);
+    return Object.fromEntries(pairs.map(([payload, payloadHash]) => [payloadHash, payload]));
+  }
+  static async addSequencedStorageMeta(payload, timestamp, index = 0) {
+    const withHashMeta = await this.addHashMeta(payload);
+    const _sequence = SequenceParser.from(timestamp, withHashMeta._hash, index).localSequence;
+    return {
+      ...withHashMeta,
+      _sequence
+    };
+  }
+  build() {
+    return {
+      schema: this._schema,
+      ...this._fields,
+      ...this._meta
+    };
+  }
+  async dataHashableFields() {
+    return await _PayloadBuilder.dataHashableFields(
+      assertEx(this._schema, () => "Payload: Missing Schema"),
+      // TODO: Add verification that required fields are present
+      this._fields
+    );
+  }
+  fields(fields) {
+    const clonedFields = structuredClone(fields);
+    const withoutEmptyFields = removeEmptyFields(clonedFields);
+    const withoutSchema = omitSchema(withoutEmptyFields);
+    const withoutStorageMeta = _PayloadBuilder.omitStorageMeta(withoutSchema);
+    this._fields = _PayloadBuilder.omitClientMeta(withoutStorageMeta);
+    return this;
+  }
+  meta(meta) {
+    this._meta = pickByPrefix(meta, "$");
+    return this;
+  }
+  schema(value) {
+    this._schema = value;
+  }
+};
+export {
+  PayloadBuilder,
+  omitSchema
+};

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

@@ -0,0 +1,64 @@
+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("@xylabs/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("@xylabs/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("@xylabs/sdk").BrandedHash | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/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("@xylabs/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("@xylabs/sdk").BrandedHash | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/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("@xylabs/sdk").BrandedHash | undefined;
+    };
+};

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

@@ -0,0 +1,34 @@
+import type { DeepOmitStartsWith, DeepPickStartsWith, EmptyObject, Hash } from '@xylabs/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/neutral/PayloadBundle.d.ts

@@ -0,0 +1,71 @@
+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("@xylabs/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("@xylabs/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("@xylabs/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("@xylabs/sdk").BrandedHash;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.payload.bundle" & {
+            readonly __schema: true;
+        };
+        payloads: {
+            schema: import("./Schema.ts").BrandedSchema<string>;
+        }[];
+        root: import("@xylabs/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("@xylabs/sdk").BrandedHash;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.payload.bundle" & {
+            readonly __schema: true;
+        };
+        payloads: {
+            schema: import("./Schema.ts").BrandedSchema<string>;
+        }[];
+        root: import("@xylabs/sdk").BrandedHash;
+    };
+};

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

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

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

@@ -0,0 +1,6 @@
+import type { Hash } from '@xylabs/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>;
+}

package/dist/_pkg/payload-model/neutral/PayloadSet/PayloadSetPayload.d.ts

@@ -0,0 +1,53 @@
+import * as z from 'zod/mini';
+export declare const PayloadSetZod: z.ZodMiniObject<{
+    optional: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniNumber<number>>>;
+    required: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniNumber<number>>>;
+}, z.core.$strip>;
+export type PayloadSet = z.infer<typeof PayloadSetZod>;
+export declare const PayloadSetPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.payload.set" & {
+        readonly __schema: true;
+    }>;
+    optional: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniNumber<number>>>;
+    required: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniNumber<number>>>;
+}, z.core.$strip>;
+export type PayloadSetPayload = z.infer<typeof PayloadSetPayloadZod>;
+export declare const isPayloadSetPayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.payload.set" & {
+        readonly __schema: true;
+    };
+    optional?: Record<string, number> | undefined;
+    required?: Record<string, number> | undefined;
+};
+export declare const asPayloadSetPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.payload.set" & {
+            readonly __schema: true;
+        };
+        optional?: Record<string, number> | undefined;
+        required?: Record<string, number> | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.payload.set" & {
+            readonly __schema: true;
+        };
+        optional?: Record<string, number> | undefined;
+        required?: Record<string, number> | undefined;
+    };
+};
+export declare const toPayloadSetPayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.payload.set" & {
+            readonly __schema: true;
+        };
+        optional?: Record<string, number> | undefined;
+        required?: Record<string, number> | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.payload.set" & {
+            readonly __schema: true;
+        };
+        optional?: Record<string, number> | undefined;
+        required?: Record<string, number> | undefined;
+    };
+};

package/dist/_pkg/payload-model/neutral/PayloadSet/PayloadSetSchema.d.ts

@@ -0,0 +1,4 @@
+export declare const PayloadSetSchema: "network.xyo.payload.set" & {
+    readonly __schema: true;
+};
+export type PayloadSetSchema = typeof PayloadSetSchema;

package/dist/_pkg/payload-model/neutral/PayloadSet/index.d.ts

@@ -0,0 +1,2 @@
+export * from './PayloadSetPayload.ts';
+export * from './PayloadSetSchema.ts';

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

@@ -0,0 +1,13 @@
+import type { Payload } from './Payload.ts';
+/**
+ * A function that validates the supplied payload synchronously
+ */
+export type SyncPayloadValidationFunction<T extends Payload = Payload> = (payload: T) => boolean;
+/**
+ * A function that validates the supplied payload asynchronously
+ */
+export type AsyncPayloadValidationFunction<T extends Payload = Payload> = (payload: T) => Promise<boolean>;
+/**
+ * A function that validates the supplied payload
+ */
+export type PayloadValidationFunction<T extends Payload = Payload> = SyncPayloadValidationFunction<T> | AsyncPayloadValidationFunction<T>;

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

@@ -0,0 +1,37 @@
+import type { Payload } from './Payload.ts';
+/**
+ * Type corresponding to the properties of a payload
+ */
+export type PayloadProperty<
+/**
+ * The type of payload
+ */
+T extends Payload = Payload> = keyof T;
+/**
+ * Type corresponding to the payload values
+ */
+export type PayloadValue<
+/**
+ * The type of payload
+ */
+T extends Payload = Payload, 
+/**
+ * The property of the payload to select
+ */
+Key extends PayloadProperty<T> = PayloadProperty<T>> = T[Key];
+/**
+ * An expressions that selects a property value from the payload
+ */
+export type PayloadValueExpression<
+/**
+ * The type of payload
+ */
+T extends Payload = Payload, 
+/**
+ * The property of the payload to select
+ */
+Key extends PayloadProperty<T> = PayloadProperty<T>, 
+/**
+ * The type of the selected property's value
+ */
+TValue = PayloadValue<T, Key>> = (payload: T) => TValue;