@xyo-network/sdk 7.0.3 → 7.0.5

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/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("@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/sdk-protocol/_pkg/payload-model/neutral/PayloadFindFilter.d.ts

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

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

@@ -1,6 +0,0 @@
-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/sdk-protocol/_pkg/payload-model/neutral/PayloadSet/PayloadSetPayload.d.ts

@@ -1,53 +0,0 @@
-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/sdk-protocol/_pkg/payload-model/neutral/PayloadSet/PayloadSetSchema.d.ts

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

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

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

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

@@ -1,13 +0,0 @@
-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/sdk-protocol/_pkg/payload-model/neutral/PayloadValueExpression.d.ts

@@ -1,37 +0,0 @@
-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;

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/PayloadZod.d.ts

@@ -1,172 +0,0 @@
-import * as z from 'zod/mini';
-import type { Payload } from './Payload.ts';
-import type { Schema } from './Schema.ts';
-export declare const HashMetaZod: z.ZodMiniObject<{
-    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-}, z.core.$strip>;
-export type HashMeta = z.infer<typeof HashMetaZod>;
-export type WithHashMeta<T extends Payload> = T & HashMeta;
-export declare const isHashMeta: <T>(value: T) => value is T & {
-    _hash: import("@xylabs/sdk").BrandedHash;
-    _dataHash: import("@xylabs/sdk").BrandedHash;
-};
-export declare const asHashMeta: {
-    <T>(value: T): (T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
-    };
-};
-export declare const toHashMeta: {
-    <T>(value: T): (T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
-    };
-};
-export declare const SequenceMetaZod: z.ZodMiniObject<{
-    _sequence: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./StorageMeta/index.ts").LocalSequence, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./StorageMeta/index.ts").QualifiedSequence, string>>]>;
-}, z.core.$strip>;
-export type SequenceMeta = z.infer<typeof SequenceMetaZod>;
-export declare const isSequenceMeta: <T>(value: T) => value is T & {
-    _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
-};
-export declare const asSequenceMeta: {
-    <T>(value: T): (T & {
-        _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
-    };
-};
-export declare const toSequenceMeta: {
-    <T>(value: T): (T & {
-        _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
-    };
-};
-export declare const StorageMetaZod: z.ZodMiniObject<{
-    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-    _sequence: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./StorageMeta/index.ts").LocalSequence, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./StorageMeta/index.ts").QualifiedSequence, string>>]>;
-}, z.core.$strip>;
-export type StorageMeta = z.infer<typeof StorageMetaZod>;
-export type WithStorageMeta<T extends Payload = Payload> = T & StorageMeta;
-export declare const isStorageMeta: <T>(value: T) => value is T & {
-    _hash: import("@xylabs/sdk").BrandedHash;
-    _dataHash: import("@xylabs/sdk").BrandedHash;
-    _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
-};
-export declare const asStorageMeta: {
-    <T>(value: T): (T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
-        _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
-        _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
-    };
-};
-export declare const toStorageMeta: {
-    <T>(value: T): (T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
-        _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        _hash: import("@xylabs/sdk").BrandedHash;
-        _dataHash: import("@xylabs/sdk").BrandedHash;
-        _sequence: import("./StorageMeta/index.ts").LocalSequence | import("./StorageMeta/index.ts").QualifiedSequence;
-    };
-};
-export declare const PayloadZod: z.ZodMiniObject<{
-    schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>;
-}, z.core.$strip>;
-export declare const isPayload: <T>(value: T) => value is T & {
-    schema: import("./Schema.ts").BrandedSchema<string>;
-};
-export declare const asPayload: {
-    <T>(value: T): (T & {
-        schema: import("./Schema.ts").BrandedSchema<string>;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        schema: import("./Schema.ts").BrandedSchema<string>;
-    };
-};
-export declare const toPayload: {
-    <T>(value: T): (T & {
-        schema: import("./Schema.ts").BrandedSchema<string>;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        schema: import("./Schema.ts").BrandedSchema<string>;
-    };
-};
-export declare const AnyPayloadZod: z.ZodMiniObject<{
-    schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>;
-}, z.core.$loose>;
-export declare const isAnyPayload: <T>(value: T) => value is T & {
-    [x: string]: unknown;
-    schema: import("./Schema.ts").BrandedSchema<string>;
-};
-export declare const asAnyPayload: {
-    <T>(value: T): (T & {
-        [x: string]: unknown;
-        schema: import("./Schema.ts").BrandedSchema<string>;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        [x: string]: unknown;
-        schema: import("./Schema.ts").BrandedSchema<string>;
-    };
-};
-export declare const toAnyPayload: {
-    <T>(value: T): (T & {
-        [x: string]: unknown;
-        schema: import("./Schema.ts").BrandedSchema<string>;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
-        [x: string]: unknown;
-        schema: import("./Schema.ts").BrandedSchema<string>;
-    };
-};
-export type AnyPayload = z.infer<typeof AnyPayloadZod>;
-export declare function WithStorageMetaZod<T extends z.core.$ZodLooseShape>(valueZod: z.ZodMiniObject<T>): z.ZodMiniObject<T & {
-    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-    _sequence: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./StorageMeta/index.ts").LocalSequence, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./StorageMeta/index.ts").QualifiedSequence, string>>]>;
-} extends infer T_1 ? { -readonly [P in keyof T_1]: T_1[P]; } : never, z.core.$strip>;
-export declare function WithHashMetaZod<T extends z.core.$ZodLooseShape>(valueZod: z.ZodMiniObject<T>): z.ZodMiniObject<T & {
-    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-} extends infer T_1 ? { -readonly [P in keyof T_1]: T_1[P]; } : never, z.core.$strip>;
-export declare const PayloadZodStrict: z.ZodMiniObject<{
-    schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>;
-}, z.core.$strict>;
-export type PayloadZodStrict = typeof PayloadZodStrict;
-export declare const PayloadZodLoose: PayloadZodStrict;
-export type PayloadZodLoose = typeof PayloadZodLoose;
-export declare const WithHashMetaPayloadZodLoose: z.ZodMiniObject<{
-    schema: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("./Schema.ts").BrandedSchema<string>, string>>;
-    _hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-    _dataHash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@xylabs/sdk").BrandedHash, string>>;
-}, z.core.$strict>;
-export type WithHashMetaPayloadZodLoose = typeof WithHashMetaPayloadZodLoose;
-export declare const PayloadZodOfSchema: <S extends Schema>(schema: S) => z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<S>;
-}, z.core.$strip>;
-export declare const PayloadZodStrictOfSchema: <S extends Schema>(schema: S) => z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<S>;
-}, z.core.$strict>;
-export declare const PayloadZodLooseOfSchema: <S extends Schema>(schema: S) => z.ZodMiniObject<{
-    schema: z.ZodMiniLiteral<S>;
-}, z.core.$strict>;

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/Query.d.ts

@@ -1,20 +0,0 @@
-import type { EmptyObject } from '@xylabs/sdk';
-import * as z from 'zod/mini';
-import type { Payload, SchemaField } from './Payload.ts';
-import type { Schema } from './Schema.ts';
-export declare const QueryFieldsZod: z.ZodMiniObject<{
-    address: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
-        readonly __hex: true;
-    } & {
-        readonly __address: true;
-    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../address/neutral/index.ts").XyoQuantAddress, string>>]>, z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
-        readonly __hex: true;
-    } & {
-        readonly __address: true;
-    }, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("../../address/neutral/index.ts").XyoQuantAddress, string>>]>>]>>;
-    budget: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-    maxFrequency: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"once">, z.ZodMiniLiteral<"second">, z.ZodMiniLiteral<"minute">, z.ZodMiniLiteral<"hour">, z.ZodMiniLiteral<"day">, z.ZodMiniLiteral<"week">, z.ZodMiniLiteral<"month">, z.ZodMiniLiteral<"year">]>>;
-    minBid: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-}, z.core.$strip>;
-export type QueryFields = z.infer<typeof QueryFieldsZod>;
-export type Query<T extends void | EmptyObject | SchemaField = void, S extends Schema | void = void> = Payload<T extends void ? QueryFields : T & QueryFields, S extends void ? T extends SchemaField ? T['schema'] : T extends void ? Schema : void : S>;

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/Schema.d.ts

@@ -1,37 +0,0 @@
-import type { Brand } from '@xylabs/sdk';
-import * as z from 'zod/mini';
-export type BrandedSchema<T extends string = string> = Brand<T, {
-    readonly __schema: true;
-}>;
-export declare const SchemaRegEx: RegExp;
-export declare const SchemaZod: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<BrandedSchema<string>, string>>;
-export type Schema<T extends string = string> = z.infer<typeof SchemaZod> & BrandedSchema<T>;
-export declare const makeSchema: <T extends string>(value: T) => z.ZodMiniPipe<z.ZodMiniLiteral<T>, z.ZodMiniTransform<Awaited<T & {
-    __schema: true;
-}>, T>>;
-export declare const isSchema: <T>(value: T) => value is T & string & {
-    readonly __schema: true;
-};
-export declare const asSchema: {
-    <T>(value: T): (T & string & {
-        readonly __schema: true;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & string & {
-        readonly __schema: true;
-    };
-};
-export declare const toSchema: {
-    <T>(value: T): (T & string & {
-        readonly __schema: true;
-    }) | undefined;
-    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & string & {
-        readonly __schema: true;
-    };
-};
-export declare const PayloadSchema: "network.xyo.payload" & {
-    readonly __schema: true;
-};
-export declare const PayloadSchemaZod: z.ZodMiniLiteral<"network.xyo.payload" & {
-    readonly __schema: true;
-}>;
-export type PayloadSchema = z.infer<typeof PayloadSchemaZod>;

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/StorageMeta/DataHash.d.ts

@@ -1,23 +0,0 @@
-import type { Hash } from '@xylabs/sdk';
-import type { Payload } from '../Payload.ts';
-export interface DataHashMeta {
-    _dataHash: Hash;
-}
-export type WithDataHashMeta<T extends Payload = Payload> = T & DataHashMeta;
-export type WithPartialDataHashMeta<T extends Payload = Payload> = Partial<WithDataHashMeta<T>>;
-export declare const isDataHashMeta: (value: unknown) => value is DataHashMeta;
-export declare const asDataHashMeta: import("@xylabs/sdk").AsTypeFunction<DataHashMeta>;
-export declare const asOptionalDataHashMeta: (value: import("@xylabs/sdk").AnyNonPromise) => DataHashMeta | undefined;
-/** @deprecated use DataHashMeta instead */
-export interface DataHashStorageMeta extends DataHashMeta {
-}
-/** @deprecated use WithDataHashMeta instead */
-export type WithDataHashStorageMeta<T extends Payload = Payload> = WithDataHashMeta<T>;
-/** @deprecated use WithPartialDataHashMeta instead */
-export type WithPartialDataHashStorageMeta<T extends Payload = Payload> = WithPartialDataHashMeta<T>;
-/** @deprecated use isDataHashMeta instead */
-export declare const isDataHashStorageMeta: (value: unknown) => value is DataHashMeta;
-/** @deprecated use asDataHashMeta instead */
-export declare const asDataHashStorageMeta: import("@xylabs/sdk").AsTypeFunction<DataHashMeta>;
-/** @deprecated use asOptionalDataHashMeta instead */
-export declare const asOptionalDataHashStorageMeta: (value: import("@xylabs/sdk").AnyNonPromise) => DataHashMeta | undefined;

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/StorageMeta/Hash.d.ts

@@ -1,24 +0,0 @@
-import type { Hash } from '@xylabs/sdk';
-import type { Payload } from '../Payload.ts';
-import type { DataHashMeta } from './DataHash.ts';
-export interface HashMeta extends DataHashMeta {
-    _hash: Hash;
-}
-export type WithHashMeta<T extends Payload = Payload> = T & HashMeta;
-export type WithPartialHashMeta<T extends Payload = Payload> = Partial<WithHashMeta<T>>;
-export declare const isHashMeta: (value: unknown) => value is HashMeta;
-export declare const asHashMeta: import("@xylabs/sdk").AsTypeFunction<HashMeta>;
-export declare const asOptionalHashMeta: (value: import("@xylabs/sdk").AnyNonPromise) => HashMeta | undefined;
-/** @deprecated use HashMeta instead */
-export interface HashStorageMeta extends HashMeta {
-}
-/** @deprecated use WithHashMeta instead */
-export type WithHashStorageMeta<T extends Payload = Payload> = WithHashMeta<T>;
-/** @deprecated use WithPartialHashMeta instead */
-export type WithPartialHashStorageMeta<T extends Payload = Payload> = Partial<WithHashMeta<T>>;
-/** @deprecated use isHashMeta instead */
-export declare const isHashStorageMeta: (value: unknown) => value is HashMeta;
-/** @deprecated use asHashMeta instead */
-export declare const asHashStorageMeta: import("@xylabs/sdk").AsTypeFunction<HashMeta>;
-/** @deprecated use asOptionalHashMeta instead */
-export declare const asOptionalHashStorageMeta: (value: import("@xylabs/sdk").AnyNonPromise) => HashMeta | undefined;

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/StorageMeta/Sequence.d.ts

@@ -1,10 +0,0 @@
-import type { Payload } from '../Payload.ts';
-import type { Sequence } from './sequence/index.ts';
-export interface SequenceStorageMeta {
-    _sequence: Sequence;
-}
-export type WithSequenceStorageMeta<T extends Payload = Payload> = T & SequenceStorageMeta;
-export type WithPartialSequenceStorageMeta<T extends Payload = Payload> = Partial<WithSequenceStorageMeta<T>>;
-export declare const isSequenceStorageMeta: (value: unknown) => value is SequenceStorageMeta;
-export declare const asSequenceStorageMeta: import("@xylabs/sdk").AsTypeFunction<SequenceStorageMeta>;
-export declare const asOptionalSequenceStorageMeta: (value: import("@xylabs/sdk").AnyNonPromise) => SequenceStorageMeta | undefined;

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

@@ -1,2 +0,0 @@
-export * from './Sequence.ts';
-export * from './sequence/index.ts';

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/StorageMeta/sequence/Comparer.d.ts

@@ -1,6 +0,0 @@
-import type { Compare } from '@xylabs/sdk';
-import type { Sequence } from './Sequence.ts';
-export declare const SequenceComparer: {
-    local: Compare<Sequence>;
-    qualified: Compare<Sequence>;
-};

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/StorageMeta/sequence/Parser.d.ts

@@ -1,30 +0,0 @@
-import type { Hash, Hex } from '@xylabs/sdk';
-import type { XyoLegacyAddress } from '../../../../address/neutral/index.ts';
-import type { Epoch, LocalSequence, Nonce, QualifiedSequence, Sequence } from './Sequence.ts';
-export declare class SequenceParser {
-    protected static privateConstructorKey: string;
-    private readonly data;
-    protected constructor(privateConstructorKey: string, hex: Hex);
-    static from(sequence: Sequence, address?: XyoLegacyAddress): SequenceParser;
-    static from(timestamp: Hex, hash: Hash, address?: XyoLegacyAddress): SequenceParser;
-    static from(timestamp: Hex, hash: Hex, address?: XyoLegacyAddress): SequenceParser;
-    static from(timestamp: Hex, nonce: Nonce, address?: XyoLegacyAddress): SequenceParser;
-    static from(timestamp: Hex, hash: Hash, index?: number, address?: XyoLegacyAddress): SequenceParser;
-    static from(timestamp: Hex, hash: Hex, index?: number, address?: XyoLegacyAddress): SequenceParser;
-    static from(timestamp: Hex, nonce: Nonce, index?: number, address?: XyoLegacyAddress): SequenceParser;
-    static from(timestamp: number, hash: Hash, address?: XyoLegacyAddress): SequenceParser;
-    static from(timestamp: number, hash: Hex, address?: XyoLegacyAddress): SequenceParser;
-    static from(timestamp: number, nonce: Nonce, address?: XyoLegacyAddress): SequenceParser;
-    static from(timestamp: number, hash: Hash, index?: number, address?: XyoLegacyAddress): SequenceParser;
-    static from(timestamp: number, hash: Hex, index?: number, address?: XyoLegacyAddress): SequenceParser;
-    static from(timestamp: number, nonce: Nonce, index?: number, address?: XyoLegacyAddress): SequenceParser;
-    static parse(value: Hex | string | ArrayBufferLike): SequenceParser;
-    static toEpoch(value: number | Hex | Epoch): Epoch;
-    static toNonce(value: Hash | Hex, index?: number): Nonce;
-    private static create;
-    get address(): XyoLegacyAddress;
-    get epoch(): Epoch;
-    get localSequence(): LocalSequence;
-    get nonce(): Nonce;
-    get qualifiedSequence(): QualifiedSequence;
-}

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/StorageMeta/sequence/Sequence.d.ts

@@ -1,79 +0,0 @@
-import type { Brand, Hex } from '@xylabs/sdk';
-import type { XyoLegacyAddress } from '../../../../address/neutral/index.ts';
-export type LocalSequence = Brand<Hex, {
-    __localSequence: true;
-}>;
-export type QualifiedSequence = Brand<Hex, {
-    __qualifiedSequence: true;
-}>;
-export type Sequence = LocalSequence | QualifiedSequence;
-export type Epoch = Brand<Hex, {
-    __epoch: true;
-}>;
-export declare const isEpoch: (value: unknown) => value is Epoch;
-export type Nonce = Brand<Hex, {
-    __nonce: true;
-}>;
-export declare const isNonce: (value: unknown) => value is Nonce;
-export declare const isLocalSequence: (value: unknown) => value is LocalSequence;
-export declare const isQualifiedSequence: (value: unknown) => value is QualifiedSequence;
-export declare const isSequence: (value: unknown) => value is Sequence;
-export declare const SequenceNonceComponentLengths: {
-    nonceIndexBytes: number;
-    nonceHashBytes: number;
-};
-export declare const SequenceComponentLengths: {
-    epochBytes: number;
-    nonceBytes: number;
-    addressBytes: number;
-    nonceIndexBytes: number;
-    nonceHashBytes: number;
-};
-export declare const SequenceComponentMinMax: {
-    minEpoch: Epoch;
-    maxEpoch: Epoch;
-    minNonce: Nonce;
-    maxNonce: Nonce;
-    minAddress: XyoLegacyAddress;
-    maxAddress: XyoLegacyAddress;
-};
-export declare const LocalSequenceConstants: {
-    localSequenceBytes: number;
-    minLocalSequence: LocalSequence;
-    maxLocalSequence: LocalSequence;
-    minEpoch: Epoch;
-    maxEpoch: Epoch;
-    minNonce: Nonce;
-    maxNonce: Nonce;
-    minAddress: XyoLegacyAddress;
-    maxAddress: XyoLegacyAddress;
-    epochBytes: number;
-    nonceBytes: number;
-    addressBytes: number;
-    nonceIndexBytes: number;
-    nonceHashBytes: number;
-};
-export declare const QualifiedSequenceConstants: {
-    qualifiedSequenceBytes: number;
-    minQualifiedSequence: QualifiedSequence;
-    maxQualifiedSequence: QualifiedSequence;
-};
-export declare const SequenceConstants: {
-    qualifiedSequenceBytes: number;
-    minQualifiedSequence: QualifiedSequence;
-    maxQualifiedSequence: QualifiedSequence;
-    localSequenceBytes: number;
-    minLocalSequence: LocalSequence;
-    maxLocalSequence: LocalSequence;
-    minEpoch: Epoch;
-    maxEpoch: Epoch;
-    minNonce: Nonce;
-    maxNonce: Nonce;
-    minAddress: XyoLegacyAddress;
-    maxAddress: XyoLegacyAddress;
-    epochBytes: number;
-    nonceBytes: number;
-    addressBytes: number;
-    nonceIndexBytes: number;
-    nonceHashBytes: number;
-};

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/StorageMeta/sequence/SequenceZod.d.ts

@@ -1,8 +0,0 @@
-import * as z from 'zod/mini';
-import type { LocalSequence, QualifiedSequence } from './Sequence.ts';
-export declare const LocalSequenceToStringZod: z.ZodMiniString<string>;
-export declare const LocalSequenceFromStringZod: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<LocalSequence, string>>;
-export declare const QualifiedSequenceToStringZod: z.ZodMiniString<string>;
-export declare const QualifiedSequenceFromStringZod: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<QualifiedSequence, string>>;
-export declare const SequenceToStringZod: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniString<string>]>;
-export declare const SequenceFromStringZod: z.ZodMiniUnion<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<LocalSequence, string>>, z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<QualifiedSequence, string>>]>;

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/StorageMeta/sequence/index.d.ts

@@ -1,4 +0,0 @@
-export * from './Comparer.ts';
-export * from './Parser.ts';
-export * from './Sequence.ts';
-export * from './SequenceZod.ts';

package/dist/_pkg/sdk-protocol/_pkg/payload-model/neutral/Timestamp.d.ts

@@ -1,7 +0,0 @@
-import type { EmptyObject } from '@xylabs/sdk';
-/** Object with a timestamp */
-export interface Timestamp {
-    timestamp: number;
-}
-/** Add a timestamp field to any object */
-export type WithTimestamp<T extends EmptyObject = EmptyObject> = T & Timestamp;