@xyo-network/xl1-protocol 4.0.11 → 4.0.14

package/dist/neutral/modules/protocol-model/model/SyncStepSummary.d.ts

@@ -0,0 +1,409 @@
+import { z } from 'zod';
+/** SyncStepSummaryMetadataZod constant. */
+export declare const SyncStepSummaryMetadataZod: z.ZodObject<{
+    block: z.ZodPipe<z.ZodInt, z.ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>;
+    blockCount: z.ZodInt;
+    bytes: z.ZodInt;
+    createdAt: z.ZodString;
+    endBlock: z.ZodPipe<z.ZodInt, z.ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>;
+    relativePath: z.ZodString;
+    startBlock: z.ZodPipe<z.ZodInt, z.ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>;
+    step: z.ZodInt;
+    stepSize: z.ZodPipe<z.ZodInt, z.ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+/** SyncStepSummaryMetadata type. */
+export type SyncStepSummaryMetadata = z.infer<typeof SyncStepSummaryMetadataZod>;
+/** Type guard that checks if a value is valid SyncStepSummaryMetadata. */
+export declare const isSyncStepSummaryMetadata: <T>(value: T) => value is T & {
+    block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+    blockCount: number;
+    bytes: number;
+    createdAt: string;
+    endBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+    relativePath: string;
+    startBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+    step: number;
+    stepSize: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+    updatedAt: string;
+};
+/** Converts a value to SyncStepSummaryMetadata, throwing if invalid. */
+export declare const asSyncStepSummaryMetadata: {
+    <T>(value: T): (T & {
+        block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        blockCount: number;
+        bytes: number;
+        createdAt: string;
+        endBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        relativePath: string;
+        startBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        step: number;
+        stepSize: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        updatedAt: string;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        blockCount: number;
+        bytes: number;
+        createdAt: string;
+        endBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        relativePath: string;
+        startBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        step: number;
+        stepSize: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        updatedAt: string;
+    };
+};
+/** toSyncStepSummaryMetadata constant. */
+export declare const toSyncStepSummaryMetadata: {
+    <T>(value: T): (T & {
+        block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        blockCount: number;
+        bytes: number;
+        createdAt: string;
+        endBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        relativePath: string;
+        startBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        step: number;
+        stepSize: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        updatedAt: string;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        blockCount: number;
+        bytes: number;
+        createdAt: string;
+        endBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        relativePath: string;
+        startBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        step: number;
+        stepSize: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        updatedAt: string;
+    };
+};
+/** SyncStepSummaryStatusZod constant. */
+export declare const SyncStepSummaryStatusZod: z.ZodObject<{
+    currentBlock: z.ZodOptional<z.ZodPipe<z.ZodInt, z.ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>>;
+    isIndexing: z.ZodBoolean;
+    nextBoundaries: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodInt, z.ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>>;
+    summaries: z.ZodArray<z.ZodObject<{
+        block: z.ZodPipe<z.ZodInt, z.ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>;
+        blockCount: z.ZodInt;
+        bytes: z.ZodInt;
+        createdAt: z.ZodString;
+        endBlock: z.ZodPipe<z.ZodInt, z.ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>;
+        relativePath: z.ZodString;
+        startBlock: z.ZodPipe<z.ZodInt, z.ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>;
+        step: z.ZodInt;
+        stepSize: z.ZodPipe<z.ZodInt, z.ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    summaryCount: z.ZodInt;
+}, z.core.$strip>;
+/** SyncStepSummaryStatus type. */
+export type SyncStepSummaryStatus = z.infer<typeof SyncStepSummaryStatusZod>;
+/** Type guard that checks if a value is valid SyncStepSummaryStatus. */
+export declare const isSyncStepSummaryStatus: <T>(value: T) => value is T & {
+    isIndexing: boolean;
+    nextBoundaries: Record<string, import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber>;
+    summaries: {
+        block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        blockCount: number;
+        bytes: number;
+        createdAt: string;
+        endBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        relativePath: string;
+        startBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        step: number;
+        stepSize: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        updatedAt: string;
+    }[];
+    summaryCount: number;
+    currentBlock?: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber | undefined;
+};
+/** Converts a value to SyncStepSummaryStatus, throwing if invalid. */
+export declare const asSyncStepSummaryStatus: {
+    <T>(value: T): (T & {
+        isIndexing: boolean;
+        nextBoundaries: Record<string, import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber>;
+        summaries: {
+            block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            blockCount: number;
+            bytes: number;
+            createdAt: string;
+            endBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            relativePath: string;
+            startBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            step: number;
+            stepSize: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            updatedAt: string;
+        }[];
+        summaryCount: number;
+        currentBlock?: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        isIndexing: boolean;
+        nextBoundaries: Record<string, import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber>;
+        summaries: {
+            block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            blockCount: number;
+            bytes: number;
+            createdAt: string;
+            endBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            relativePath: string;
+            startBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            step: number;
+            stepSize: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            updatedAt: string;
+        }[];
+        summaryCount: number;
+        currentBlock?: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber | undefined;
+    };
+};
+/** toSyncStepSummaryStatus constant. */
+export declare const toSyncStepSummaryStatus: {
+    <T>(value: T): (T & {
+        isIndexing: boolean;
+        nextBoundaries: Record<string, import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber>;
+        summaries: {
+            block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            blockCount: number;
+            bytes: number;
+            createdAt: string;
+            endBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            relativePath: string;
+            startBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            step: number;
+            stepSize: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            updatedAt: string;
+        }[];
+        summaryCount: number;
+        currentBlock?: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        isIndexing: boolean;
+        nextBoundaries: Record<string, import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber>;
+        summaries: {
+            block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            blockCount: number;
+            bytes: number;
+            createdAt: string;
+            endBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            relativePath: string;
+            startBlock: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            step: number;
+            stepSize: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+            updatedAt: string;
+        }[];
+        summaryCount: number;
+        currentBlock?: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber | undefined;
+    };
+};
+/** SyncStepSummaryZod constant. */
+export declare const SyncStepSummaryZod: z.ZodArray<import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniObject<{
+    schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
+        readonly __schema: true;
+    }>;
+    addresses: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
+    payload_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    payload_schemas: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>>;
+    previous_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+    $destination: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
+    $sourceQuery: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    $signatures: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
+    block: z.ZodPipe<z.ZodInt, z.ZodTransform<import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber, number>>;
+    chain: z.ZodPipe<z.ZodString, z.ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+    previous: import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    protocol: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
+    step_hashes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+    $epoch: import("zod/mini").ZodMiniNumber<number>;
+    _hash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    _dataHash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
+    schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>;
+    _hash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    _dataHash: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$loose>>], null>>;
+/** SyncStepSummary type. */
+export type SyncStepSummary = z.infer<typeof SyncStepSummaryZod>;
+/** Type guard that checks if a value is a valid SyncStepSummary. */
+export declare const isSyncStepSummary: <T>(value: T) => value is T & [{
+    schema: "network.xyo.boundwitness" & {
+        readonly __schema: true;
+    };
+    addresses: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }))[];
+    payload_hashes: import("@ariestools/sdk").BrandedHash[];
+    payload_schemas: import("@xyo-network/sdk-protocol").BrandedSchema<string>[];
+    previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+    $signatures: import("@ariestools/sdk").BrandedHex[];
+    block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+    chain: import("@ariestools/sdk").BrandedHex;
+    previous: import("@ariestools/sdk").BrandedHash | null;
+    $epoch: number;
+    _hash: import("@ariestools/sdk").BrandedHash;
+    _dataHash: import("@ariestools/sdk").BrandedHash;
+    $destination?: import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | undefined;
+    $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+    protocol?: number | undefined;
+    step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+}, {
+    [x: string]: unknown;
+    schema: import("@xyo-network/sdk-protocol").BrandedSchema<string>;
+    _hash: import("@ariestools/sdk").BrandedHash;
+    _dataHash: import("@ariestools/sdk").BrandedHash;
+}[]][];
+/** Converts a value to SyncStepSummary, throwing if invalid. */
+export declare const asSyncStepSummary: {
+    <T>(value: T): (T & [{
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }))[];
+        payload_hashes: import("@ariestools/sdk").BrandedHash[];
+        payload_schemas: import("@xyo-network/sdk-protocol").BrandedSchema<string>[];
+        previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+        $signatures: import("@ariestools/sdk").BrandedHex[];
+        block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        chain: import("@ariestools/sdk").BrandedHex;
+        previous: import("@ariestools/sdk").BrandedHash | null;
+        $epoch: number;
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
+        $destination?: import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+    }, {
+        [x: string]: unknown;
+        schema: import("@xyo-network/sdk-protocol").BrandedSchema<string>;
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
+    }[]][]) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & [{
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }))[];
+        payload_hashes: import("@ariestools/sdk").BrandedHash[];
+        payload_schemas: import("@xyo-network/sdk-protocol").BrandedSchema<string>[];
+        previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+        $signatures: import("@ariestools/sdk").BrandedHex[];
+        block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        chain: import("@ariestools/sdk").BrandedHex;
+        previous: import("@ariestools/sdk").BrandedHash | null;
+        $epoch: number;
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
+        $destination?: import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+    }, {
+        [x: string]: unknown;
+        schema: import("@xyo-network/sdk-protocol").BrandedSchema<string>;
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
+    }[]][];
+};
+/** toSyncStepSummary constant. */
+export declare const toSyncStepSummary: {
+    <T>(value: T): (T & [{
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }))[];
+        payload_hashes: import("@ariestools/sdk").BrandedHash[];
+        payload_schemas: import("@xyo-network/sdk-protocol").BrandedSchema<string>[];
+        previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+        $signatures: import("@ariestools/sdk").BrandedHex[];
+        block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        chain: import("@ariestools/sdk").BrandedHex;
+        previous: import("@ariestools/sdk").BrandedHash | null;
+        $epoch: number;
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
+        $destination?: import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+    }, {
+        [x: string]: unknown;
+        schema: import("@xyo-network/sdk-protocol").BrandedSchema<string>;
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
+    }[]][]) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & [{
+        schema: "network.xyo.boundwitness" & {
+            readonly __schema: true;
+        };
+        addresses: (import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }))[];
+        payload_hashes: import("@ariestools/sdk").BrandedHash[];
+        payload_schemas: import("@xyo-network/sdk-protocol").BrandedSchema<string>[];
+        previous_hashes: (import("@ariestools/sdk").BrandedHash | null)[];
+        $signatures: import("@ariestools/sdk").BrandedHex[];
+        block: import('../BlockNumber/xl1BlockNumber.js').XL1BlockNumber;
+        chain: import("@ariestools/sdk").BrandedHex;
+        previous: import("@ariestools/sdk").BrandedHash | null;
+        $epoch: number;
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
+        $destination?: import("@xyo-network/sdk-protocol").XyoQuantAddress | (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | undefined;
+        $sourceQuery?: import("@ariestools/sdk").BrandedHash | undefined;
+        protocol?: number | undefined;
+        step_hashes?: import("@ariestools/sdk").BrandedHash[] | undefined;
+    }, {
+        [x: string]: unknown;
+        schema: import("@xyo-network/sdk-protocol").BrandedSchema<string>;
+        _hash: import("@ariestools/sdk").BrandedHash;
+        _dataHash: import("@ariestools/sdk").BrandedHash;
+    }[]][];
+};
+//# sourceMappingURL=SyncStepSummary.d.ts.map

package/dist/neutral/modules/protocol-model/model/SyncStepSummary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyncStepSummary.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/SyncStepSummary.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,2CAA2C;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;;;iBAWrC,CAAA;AAEF,oCAAoC;AACpC,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEhF,0EAA0E;AAC1E,eAAO,MAAM,yBAAyB;;;;;;;;;;;CAA2C,CAAA;AACjF,wEAAwE;AACxE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;CAAwE,CAAA;AAC9G,0CAA0C;AAC1C,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;CAAwE,CAAA;AAE9G,yCAAyC;AACzC,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;iBAMnC,CAAA;AAEF,kCAAkC;AAClC,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE5E,wEAAwE;AACxE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;CAAyC,CAAA;AAC7E,sEAAsE;AACtE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoE,CAAA;AACxG,wCAAwC;AACxC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoE,CAAA;AAExG,mCAAmC;AACnC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAA8C,CAAA;AAE7E,4BAA4B;AAC5B,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,oEAAoE;AACpE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAmC,CAAA;AACjE,gEAAgE;AAChE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAA;AACtF,kCAAkC;AAClC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAA"}

package/dist/neutral/modules/protocol-model/model/TimeDomain.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+/** TimeDomainZod constant. */
+export declare const TimeDomainZod: z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>;
+//# sourceMappingURL=TimeDomain.d.ts.map

package/dist/neutral/modules/protocol-model/model/TimeDomain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimeDomain.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/TimeDomain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,8BAA8B;AAC9B,eAAO,MAAM,aAAa,6FAIxB,CAAA"}

package/dist/neutral/modules/protocol-model/model/TransferPair.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+/** TransferPairZod constant. */
+export declare const TransferPairZod: z.ZodTuple<[import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+    readonly __hex: true;
+} & {
+    readonly __address: true;
+}, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>, import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+    readonly __hex: true;
+} & {
+    readonly __address: true;
+}, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>], null>;
+//# sourceMappingURL=TransferPair.d.ts.map

package/dist/neutral/modules/protocol-model/model/TransferPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransferPair.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/TransferPair.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,gCAAgC;AAChC,eAAO,MAAM,eAAe;;;;;;;;wLAE1B,CAAA"}

package/dist/neutral/modules/protocol-model/model/addresses.d.ts

@@ -0,0 +1,28 @@
+import type { Address, EthAddress } from '@ariestools/sdk';
+/**
+ * The Zero Address is used as a marker address for various protocol operations.
+ */
+export declare const XYO_ZERO_ADDRESS: Address;
+/**
+ * The Bridge Address is used as a marker address for bridge transactions.
+ */
+export declare const XYO_BRIDGE_ADDRESS: Address;
+/**
+ * The Network Staking Address is used as a marker address for staking the network.
+ */
+export declare const XYO_NETWORK_STAKING_ADDRESS: Address;
+/**
+ * The Step Reward Address is used as a marker address for step rewards.
+ */
+export declare const XYO_STEP_REWARD_ADDRESS: Address;
+/** XL1_ETH_MAIN_ERC20_CONTRACT_ADDRESS constant. */
+export declare const XL1_ETH_MAIN_ERC20_CONTRACT_ADDRESS: EthAddress;
+/** XL1_ETH_MAIN_SUB_GOVERNOR_ADDRESS constant. */
+export declare const XL1_ETH_MAIN_SUB_GOVERNOR_ADDRESS: EthAddress;
+/** XL1_ETH_MAIN_REWARDS_ADDRESS constant. */
+export declare const XL1_ETH_MAIN_REWARDS_ADDRESS: EthAddress;
+/** XL1_ETH_MAIN_STAKED_XYO_CHAIN_ADDRESS constant. */
+export declare const XL1_ETH_MAIN_STAKED_XYO_CHAIN_ADDRESS: EthAddress;
+/** XL1_ETH_MAIN_GOVERNANCE_ADDRESS constant. */
+export declare const XL1_ETH_MAIN_GOVERNANCE_ADDRESS: EthAddress;
+//# sourceMappingURL=addresses.d.ts.map

package/dist/neutral/modules/protocol-model/model/addresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/addresses.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE1D;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAA0D,OAAO,CAAA;AAE9F;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAA0D,OAAO,CAAA;AAEhG;;GAEG;AACH,eAAO,MAAM,2BAA2B,EAA0D,OAAO,CAAA;AAEzG;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAA0D,OAAO,CAAA;AAErG,oDAAoD;AACpD,eAAO,MAAM,mCAAmC,EAA4D,UAAU,CAAA;AAEtH,kDAAkD;AAClD,eAAO,MAAM,iCAAiC,EAA4D,UAAU,CAAA;AAEpH,6CAA6C;AAC7C,eAAO,MAAM,4BAA4B,EAA4D,UAAU,CAAA;AAE/G,sDAAsD;AACtD,eAAO,MAAM,qCAAqC,EAA4D,UAAU,CAAA;AAExH,gDAAgD;AAChD,eAAO,MAAM,+BAA+B,EAA4D,UAAU,CAAA"}

package/dist/neutral/modules/protocol-model/model/defaultRewardRatio.d.ts

@@ -0,0 +1,3 @@
+/** defaultRewardRatio value. */
+export declare const defaultRewardRatio: 0.05;
+//# sourceMappingURL=defaultRewardRatio.d.ts.map

package/dist/neutral/modules/protocol-model/model/defaultRewardRatio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultRewardRatio.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/defaultRewardRatio.ts"],"names":[],"mappings":"AACA,gCAAgC;AAChC,eAAO,MAAM,kBAAkB,EAAG,IAAa,CAAA"}

package/dist/neutral/modules/protocol-model/model/defaultTransactionFees.d.ts

@@ -0,0 +1,4 @@
+import type { TransactionFeesBigInt } from '../transaction/index.js';
+/** defaultTransactionFees value. */
+export declare const defaultTransactionFees: TransactionFeesBigInt;
+//# sourceMappingURL=defaultTransactionFees.d.ts.map

package/dist/neutral/modules/protocol-model/model/defaultTransactionFees.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultTransactionFees.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/defaultTransactionFees.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AAIpE,oCAAoC;AACpC,eAAO,MAAM,sBAAsB,EAAE,qBAK3B,CAAA"}

package/dist/neutral/modules/protocol-model/model/index.d.ts

@@ -0,0 +1,28 @@
+export * from './AccountBalance.js';
+export * from './addresses.js';
+export * from './ArrayBuffer.js';
+export * from './BlockRange/index.js';
+export * from './BlockRate.js';
+export * from './ChainQualification.js';
+export * from './Context/index.js';
+export * from './defaultRewardRatio.js';
+export * from './defaultTransactionFees.js';
+export * from './GatewayName.js';
+export * from './HydratedTransaction.js';
+export * from './minTransactionFees.js';
+export * from './OpCodes.js';
+export * from './PayloadMap.js';
+export * from './Permission.js';
+export * from './Position.js';
+export * from './PositionId.js';
+export * from './RangeMultipliers.js';
+export * from './rewards.js';
+export * from './RewardShare.js';
+export * from './RewardsRangeOptions.js';
+export * from './Sequence.js';
+export * from './Stake.js';
+export * from './SyncStepSummary.js';
+export * from './TimeDomain.js';
+export * from './TransferPair.js';
+export * from './version.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/protocol-model/model/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,yBAAyB,CAAA;AACvC,cAAc,oBAAoB,CAAA;AAClC,cAAc,yBAAyB,CAAA;AACvC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,kBAAkB,CAAA;AAChC,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,cAAc,0BAA0B,CAAA;AACxC,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,sBAAsB,CAAA;AACpC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,cAAc,CAAA"}

package/dist/neutral/modules/protocol-model/model/minTransactionFees.d.ts

@@ -0,0 +1,4 @@
+import type { TransactionFeesBigInt } from '../transaction/index.js';
+/** minTransactionFees value. */
+export declare const minTransactionFees: TransactionFeesBigInt;
+//# sourceMappingURL=minTransactionFees.d.ts.map

package/dist/neutral/modules/protocol-model/model/minTransactionFees.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minTransactionFees.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/minTransactionFees.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AAGpE,gCAAgC;AAChC,eAAO,MAAM,kBAAkB,EAAE,qBAKvB,CAAA"}

package/dist/neutral/modules/protocol-model/model/rewards.d.ts

@@ -0,0 +1,15 @@
+/** XL1_REWARDS_PLACES constant. */
+export declare const XL1_REWARDS_PLACES: 18;
+/** XL1_REWARDS_STARTING_REWARD constant. */
+export declare const XL1_REWARDS_STARTING_REWARD: import('../xl1/attoXl1.js').AttoXL1;
+/** XL1_REWARDS_BLOCKS_PER_STEP constant. */
+export declare const XL1_REWARDS_BLOCKS_PER_STEP = 1000000;
+/** XL1_REWARDS_STEP_FACTOR_NUMERATOR constant. */
+export declare const XL1_REWARDS_STEP_FACTOR_NUMERATOR = 95n;
+/** XL1_REWARDS_STEP_FACTOR_DENOMINATOR constant. */
+export declare const XL1_REWARDS_STEP_FACTOR_DENOMINATOR = 100n;
+/** XL1_REWARDS_MIN_BLOCK_REWARD constant. */
+export declare const XL1_REWARDS_MIN_BLOCK_REWARD: import('../xl1/attoXl1.js').AttoXL1;
+/** XL1_REWARDS_CREATOR_REWARD constant. */
+export declare const XL1_REWARDS_CREATOR_REWARD: import('../xl1/attoXl1.js').AttoXL1;
+//# sourceMappingURL=rewards.d.ts.map

package/dist/neutral/modules/protocol-model/model/rewards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewards.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/rewards.ts"],"names":[],"mappings":"AAIA,mCAAmC;AACnC,eAAO,MAAM,kBAAkB,EAAG,EAAW,CAAA;AAC7C,4CAA4C;AAC5C,eAAO,MAAM,2BAA2B,qCAAoD,CAAA;AAC5F,4CAA4C;AAC5C,eAAO,MAAM,2BAA2B,UAAY,CAAA;AACpD,kDAAkD;AAClD,eAAO,MAAM,iCAAiC,MAAM,CAAA;AACpD,oDAAoD;AACpD,eAAO,MAAM,mCAAmC,OAAO,CAAA;AACvD,6CAA6C;AAC7C,eAAO,MAAM,4BAA4B,qCAAmD,CAAA;AAC5F,2CAA2C;AAC3C,eAAO,MAAM,0BAA0B,qCAA+D,CAAA"}

package/dist/neutral/modules/protocol-model/model/version.d.ts

@@ -0,0 +1,11 @@
+/** XL1_PROTOCOL_VERSION_MAJOR constant. */
+export declare const XL1_PROTOCOL_VERSION_MAJOR: 1;
+/** XL1_PROTOCOL_VERSION_MINOR constant. */
+export declare const XL1_PROTOCOL_VERSION_MINOR: 2;
+/** XL1_PROTOCOL_VERSION_PATCH constant. */
+export declare const XL1_PROTOCOL_VERSION_PATCH: 0;
+/** XL1_PROTOCOL_VERSION_STRING constant. */
+export declare const XL1_PROTOCOL_VERSION_STRING: "1.2.0";
+/** XL1_PROTOCOL_VERSION constant. */
+export declare const XL1_PROTOCOL_VERSION: number;
+//# sourceMappingURL=version.d.ts.map

package/dist/neutral/modules/protocol-model/model/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/model/version.ts"],"names":[],"mappings":"AAAA,2CAA2C;AAC3C,eAAO,MAAM,0BAA0B,EAAG,CAAU,CAAA;AACpD,2CAA2C;AAC3C,eAAO,MAAM,0BAA0B,EAAG,CAAU,CAAA;AACpD,2CAA2C;AAC3C,eAAO,MAAM,0BAA0B,EAAG,CAAU,CAAA;AACpD,4CAA4C;AAC5C,eAAO,MAAM,2BAA2B,SAAuG,CAAA;AAC/I,qCAAqC;AACrC,eAAO,MAAM,oBAAoB,QAA0G,CAAA"}

package/dist/neutral/modules/protocol-model/payload/StepIdentityPayload.d.ts

@@ -0,0 +1,20 @@
+import type { Payload } from '@xyo-network/sdk';
+import type { z } from 'zod';
+import { StepIdentityZod } from '../Step/index.js';
+/** Schema identifier for step identity payloads. */
+export declare const StepIdentitySchema: "network.xyo.chain.step.identity" & {
+    readonly __schema: true;
+};
+/** Schema type for StepIdentity payloads. */
+export type StepIdentitySchema = typeof StepIdentitySchema;
+/** Fields for a step identity, inferred from the StepIdentityZod schema. */
+export type StepIdentityFields = z.infer<typeof StepIdentityZod>;
+/**
+ * A Step Identity Payload
+ */
+export type StepIdentityPayload = Payload<StepIdentityFields, StepIdentitySchema>;
+/** Type guard that checks whether a value is a StepIdentityPayload. */
+export declare const isStepIdentityPayload: (x?: unknown) => x is StepIdentityPayload;
+/** Casts a value to StepIdentityPayload or returns undefined if it does not match. */
+export declare const asStepIdentityPayload: import("@ariestools/sdk").AsTypeFunction<StepIdentityPayload>;
+//# sourceMappingURL=StepIdentityPayload.d.ts.map

package/dist/neutral/modules/protocol-model/payload/StepIdentityPayload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepIdentityPayload.d.ts","sourceRoot":"","sources":["../../../../../src/modules/protocol-model/payload/StepIdentityPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE/C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAElD,oDAAoD;AACpD,eAAO,MAAM,kBAAkB;;CAAoD,CAAA;AACnF,6CAA6C;AAC7C,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA;AAE1D,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEhE;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,CAAA;AAEjF,uEAAuE;AACvE,eAAO,MAAM,qBAAqB,2CAA+E,CAAA;AAEjH,sFAAsF;AACtF,eAAO,MAAM,qBAAqB,+DAAgD,CAAA"}

package/dist/neutral/modules/protocol-model/payload/application/Exchange/ExchangeOutcome.d.ts

@@ -0,0 +1,29 @@
+import type { Payload } from '@xyo-network/sdk';
+import { z } from 'zod/mini';
+/** Schema identifier for ExchangeOutcome payloads. */
+export declare const ExchangeOutcomeSchema: "network.xyo.exchange.outcome" & {
+    readonly __schema: true;
+};
+/** Schema type for ExchangeOutcome payloads. */
+export type ExchangeOutcomeSchema = typeof ExchangeOutcomeSchema;
+/**
+ * Fields for an ExchangeOutcome payload — the lean settlement record. Co-signed by every
+ * required party in the settlement BoundWitness, with the secret reveals and authority
+ * attestations carried as co-payloads in that BW.
+ */
+export declare const ExchangeOutcomeFieldsZod: z.ZodMiniObject<{
+    terms: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    outcome: z.ZodMiniEnum<{
+        fulfilled: "fulfilled";
+        rejected: "rejected";
+    }>;
+}, z.core.$strip>;
+/** ExchangeOutcomeFields type. */
+export type ExchangeOutcomeFields = z.infer<typeof ExchangeOutcomeFieldsZod>;
+/** An ExchangeOutcome payload — the settlement result of an atomic exchange. */
+export type ExchangeOutcome = Payload<ExchangeOutcomeFields, ExchangeOutcomeSchema>;
+/** Type guard that checks if a value is a valid ExchangeOutcome. */
+export declare const isExchangeOutcome: (x?: unknown) => x is ExchangeOutcome;
+/** Casts a value to ExchangeOutcome or returns undefined if invalid. */
+export declare const asExchangeOutcome: import("@ariestools/sdk").AsTypeFunction<ExchangeOutcome>;
+//# sourceMappingURL=ExchangeOutcome.d.ts.map