@xyo-network/xl1-protocol 5.4.1 → 5.5.0

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

@@ -1,6 +1,4 @@
-import type { Hash } from '@ariestools/sdk';
-import type { Payload } from '@xyo-network/sdk';
-import type { FromFields } from './Executable.js';
+import { z } from 'zod/mini';
 /** Schema identifier for StepComplete payloads. */
 export declare const StepCompleteSchema: "network.xyo.chain.step.complete" & {
     readonly __schema: true;
@@ -8,20 +6,117 @@ export declare const StepCompleteSchema: "network.xyo.chain.step.complete" & {
 /** Schema type for StepComplete payloads. */
 export type StepCompleteSchema = typeof StepCompleteSchema;
 /** Records completion metadata for a reward-eligible network step. */
-export interface StepCompleteFields extends FromFields {
-    /** XL1 block number at the step head. */
+export declare const StepCompleteFieldsZod: z.ZodMiniObject<{
+    block: z.ZodMiniNumber<number>;
+    from: 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("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+    hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    size: z.ZodMiniNumber<number>;
+    stakeBlock: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+/** Fields represented by the Step Complete contract. */
+export type StepCompleteFields = z.infer<typeof StepCompleteFieldsZod>;
+/** Zod schema for a complete StepComplete including schema and fields. */
+export declare const StepCompleteZod: z.ZodMiniObject<{
+    $version: z.ZodMiniOptional<z.ZodMiniNumberFormat<z.core.$ZodNumberFormats>>;
+    schema: z.ZodMiniLiteral<"network.xyo.chain.step.complete" & {
+        readonly __schema: true;
+    }>;
+    block: z.ZodMiniNumber<number>;
+    from: 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("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+    hash: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    size: z.ZodMiniNumber<number>;
+    stakeBlock: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+/** Validated data representation for Step Complete. */
+export type StepComplete = z.infer<typeof StepCompleteZod>;
+/** Type guard that checks if a value is a valid StepComplete. */
+export declare const isStepComplete: <T>(value: T) => value is T & {
+    schema: "network.xyo.chain.step.complete" & {
+        readonly __schema: true;
+    };
     block: number;
-    /** Hash that identifies the completed step. */
-    hash: Hash;
-    /** Number of XL1 blocks represented by the step. */
+    from: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("@xyo-network/sdk").XyoQuantAddress;
+    hash: import("@ariestools/sdk").BrandedHash;
     size: number;
-    /** Reference block number on the external staking system. */
     stakeBlock: number;
-}
-/** Validated data representation for Step Complete. */
-export type StepComplete = Payload<StepCompleteFields, StepCompleteSchema>;
-/** Type guard that checks if a value is a valid StepComplete. */
-export declare const isStepComplete: (x?: unknown) => x is StepComplete;
-/** Converts a value to StepComplete, throwing if invalid. */
-export declare const asStepComplete: import("@ariestools/sdk").AsTypeFunction<StepComplete>;
+    $version?: number | undefined;
+};
+/** Casts a value to StepComplete or returns undefined if invalid. */
+export declare const asStepComplete: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.chain.step.complete" & {
+            readonly __schema: true;
+        };
+        block: number;
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        hash: import("@ariestools/sdk").BrandedHash;
+        size: number;
+        stakeBlock: number;
+        $version?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.chain.step.complete" & {
+            readonly __schema: true;
+        };
+        block: number;
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        hash: import("@ariestools/sdk").BrandedHash;
+        size: number;
+        stakeBlock: number;
+        $version?: number | undefined;
+    };
+};
+/** Coerces a value to StepComplete or returns undefined if invalid. */
+export declare const toStepComplete: {
+    (value: unknown): {
+        schema: "network.xyo.chain.step.complete" & {
+            readonly __schema: true;
+        };
+        block: number;
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        hash: import("@ariestools/sdk").BrandedHash;
+        size: number;
+        stakeBlock: number;
+        $version?: number | undefined;
+    } | undefined;
+    (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
+        schema: "network.xyo.chain.step.complete" & {
+            readonly __schema: true;
+        };
+        block: number;
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        hash: import("@ariestools/sdk").BrandedHash;
+        size: number;
+        stakeBlock: number;
+        $version?: number | undefined;
+    };
+};
 //# sourceMappingURL=StepComplete.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"StepComplete.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/elevatable/StepComplete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD,mDAAmD;AACnD,eAAO,MAAM,kBAAkB;;CAAoD,CAAA;AACnF,6CAA6C;AAC7C,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA;AAE1D,sEAAsE;AACtE,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAA;IAEb,+CAA+C;IAC/C,IAAI,EAAE,IAAI,CAAA;IAEV,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAA;IAEZ,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAA;CACnB;AAGD,uDAAuD;AACvD,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,CAAA;AAE1E,iEAAiE;AACjE,eAAO,MAAM,cAAc,oCAA0D,CAAA;AAErF,6DAA6D;AAC7D,eAAO,MAAM,cAAc,wDAAyC,CAAA"}
+{"version":3,"file":"StepComplete.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/elevatable/StepComplete.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,mDAAmD;AACnD,eAAO,MAAM,kBAAkB;;CAAoD,CAAA;AACnF,6CAA6C;AAC7C,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAA;AAE1D,sEAAsE;AACtE,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAWhC,CAAA;AAEF,wDAAwD;AACxD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEtE,0EAA0E;AAC1E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;iBAAgF,CAAA;AAG5G,uDAAuD;AACvD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE1D,iEAAiE;AACjE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;CAAgC,CAAA;AAC3D,qEAAqE;AACrE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkD,CAAA;AAC7E,uEAAuE;AACvE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkD,CAAA"}

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

@@ -1,3 +1,4 @@
+import type { WithStorageMeta } from '@xyo-network/sdk';
 import { z } from 'zod/mini';
 /** Supported time domains: xl1 block number, epoch timestamp, or ethereum block number. */
 export type TimeDomain = 'xl1' | 'epoch' | 'ethereum';
@@ -17,9 +18,11 @@ export declare const EthereumTimeFieldsZod: z.ZodMiniObject<{
     ethereum: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
     ethereumHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
 }, z.core.$strip>;
+/** Maximum accepted epoch timestamp in milliseconds (~year 2286). */
+export declare const MAX_SAFE_EPOCH = 9999999999999;
 /** Zod schema for epoch time fields in milliseconds. */
 export declare const EpochTimeFieldsZod: z.ZodMiniObject<{
-    epoch: z.ZodMiniNumber<number>;
+    epoch: z.ZodMiniInt;
 }, z.core.$strip>;
 /** Combined Zod schema for all time fields across XL1, Ethereum, and epoch domains. */
 export declare const TimeFieldsZod: z.ZodMiniObject<{
@@ -27,7 +30,7 @@ export declare const TimeFieldsZod: z.ZodMiniObject<{
     xl1Hash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
     ethereum: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
     ethereumHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-    epoch: z.ZodMiniNumber<number>;
+    epoch: z.ZodMiniInt;
 }, z.core.$strip>;
 /** Zod schema for a complete time payload including schema and all time fields. */
 export declare const TimePayloadZod: z.ZodMiniObject<{
@@ -39,18 +42,14 @@ export declare const TimePayloadZod: z.ZodMiniObject<{
     xl1Hash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
     ethereum: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
     ethereumHash: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
-    epoch: z.ZodMiniNumber<number>;
+    epoch: z.ZodMiniInt;
 }, z.core.$strip>;
 /** A payload containing time information across multiple domains. */
 export type TimePayload = z.infer<typeof TimePayloadZod>;
-/** Maximum accepted epoch timestamp in milliseconds (~year 2286). */
-export declare const MAX_SAFE_EPOCH = 9999999999999;
 /** Checks whether a value is a safe epoch timestamp (nonnegative safe integer within the protocol cap). */
 export declare const isSafeEpoch: (value: unknown) => value is number;
-/** Type guard that checks whether a value is a valid TimePayload with a safe epoch. */
-export declare const isTimePayload: (value: unknown) => value is TimePayload;
-/** Casts a value to TimePayload or returns undefined if it does not match. */
-export declare const asTimePayload: import("@ariestools/sdk").AsTypeFunction<{
+/** Type guard that validates the full TimePayload shape (schema, version, and safe epoch). */
+export declare const isTimePayload: <T>(value: T) => value is T & {
     schema: "network.xyo.time" & {
         readonly __schema: true;
     };
@@ -60,17 +59,59 @@ export declare const asTimePayload: import("@ariestools/sdk").AsTypeFunction<{
     xl1Hash?: import("@ariestools/sdk").BrandedHash | undefined;
     ethereum?: number | undefined;
     ethereumHash?: import("@ariestools/sdk").BrandedHash | undefined;
-}>;
-/** Casts a value to TimePayload with storage metadata or returns undefined. */
-export declare const asTimePayloadWithStorageMeta: import("@ariestools/sdk").AsTypeFunction<{
-    schema: "network.xyo.time" & {
-        readonly __schema: true;
+};
+/** Casts a value to TimePayload or returns undefined if it does not match. */
+export declare const asTimePayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.time" & {
+            readonly __schema: true;
+        };
+        epoch: number;
+        $version?: 1000000 | undefined;
+        xl1?: number | undefined;
+        xl1Hash?: import("@ariestools/sdk").BrandedHash | undefined;
+        ethereum?: number | undefined;
+        ethereumHash?: import("@ariestools/sdk").BrandedHash | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.time" & {
+            readonly __schema: true;
+        };
+        epoch: number;
+        $version?: 1000000 | undefined;
+        xl1?: number | undefined;
+        xl1Hash?: import("@ariestools/sdk").BrandedHash | undefined;
+        ethereum?: number | undefined;
+        ethereumHash?: import("@ariestools/sdk").BrandedHash | undefined;
     };
-    epoch: number;
-    $version?: 1000000 | undefined;
-    xl1?: number | undefined;
-    xl1Hash?: import("@ariestools/sdk").BrandedHash | undefined;
-    ethereum?: number | undefined;
-    ethereumHash?: import("@ariestools/sdk").BrandedHash | undefined;
-}>;
+};
+/** Coerces a value to TimePayload or returns undefined if it does not match. */
+export declare const toTimePayload: {
+    (value: unknown): {
+        schema: "network.xyo.time" & {
+            readonly __schema: true;
+        };
+        epoch: number;
+        $version?: 1000000 | undefined;
+        xl1?: number | undefined;
+        xl1Hash?: import("@ariestools/sdk").BrandedHash | undefined;
+        ethereum?: number | undefined;
+        ethereumHash?: import("@ariestools/sdk").BrandedHash | undefined;
+    } | undefined;
+    (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
+        schema: "network.xyo.time" & {
+            readonly __schema: true;
+        };
+        epoch: number;
+        $version?: 1000000 | undefined;
+        xl1?: number | undefined;
+        xl1Hash?: import("@ariestools/sdk").BrandedHash | undefined;
+        ethereum?: number | undefined;
+        ethereumHash?: import("@ariestools/sdk").BrandedHash | undefined;
+    };
+};
+/** Type guard that checks whether a value is a TimePayload with storage metadata. */
+export declare const isTimePayloadWithStorageMeta: (value: unknown) => value is WithStorageMeta<TimePayload>;
+/** Casts a value to TimePayload with storage metadata or returns undefined. */
+export declare const asTimePayloadWithStorageMeta: (value: unknown) => WithStorageMeta<TimePayload> | undefined;
 //# sourceMappingURL=Time.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Time.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/elevatable/Time.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,2FAA2F;AAC3F,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,OAAO,GAAG,UAAU,CAAA;AAErD,2CAA2C;AAC3C,eAAO,MAAM,UAAU;;CAAqC,CAAA;AAC5D,qCAAqC;AACrC,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAA;AAE1C,sEAAsE;AACtE,eAAO,MAAM,gBAAgB;;;iBAK3B,CAAA;AAEF,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB;;;iBAKhC,CAAA;AAEF,wDAAwD;AACxD,eAAO,MAAM,kBAAkB;;iBAG7B,CAAA;AAEF,uFAAuF;AACvF,eAAO,MAAM,aAAa;;;;;;iBAGzB,CAAA;AAED,mFAAmF;AACnF,eAAO,MAAM,cAAc;;;;;;;;;;iBAGzB,CAAA;AAEF,qEAAqE;AACrE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAMxD,qEAAqE;AACrE,eAAO,MAAM,cAAc,gBAAoB,CAAA;AAE/C,2GAA2G;AAC3G,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAGrD,CAAA;AAED,uFAAuF;AACvF,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAGvD,CAAA;AAED,8EAA8E;AAC9E,eAAO,MAAM,aAAa;;;;;;;;;;EAAwC,CAAA;AAClE,+EAA+E;AAC/E,eAAO,MAAM,4BAA4B;;;;;;;;;;EAAwC,CAAA"}
+{"version":3,"file":"Time.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/elevatable/Time.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAIvD,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,2FAA2F;AAC3F,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,OAAO,GAAG,UAAU,CAAA;AAErD,2CAA2C;AAC3C,eAAO,MAAM,UAAU;;CAAqC,CAAA;AAC5D,qCAAqC;AACrC,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAA;AAE1C,sEAAsE;AACtE,eAAO,MAAM,gBAAgB;;;iBAK3B,CAAA;AAEF,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB;;;iBAKhC,CAAA;AAIF,qEAAqE;AACrE,eAAO,MAAM,cAAc,gBAAoB,CAAA;AAE/C,wDAAwD;AACxD,eAAO,MAAM,kBAAkB;;iBAG7B,CAAA;AAEF,uFAAuF;AACvF,eAAO,MAAM,aAAa;;;;;;iBAGzB,CAAA;AAED,mFAAmF;AACnF,eAAO,MAAM,cAAc;;;;;;;;;;iBAGzB,CAAA;AAEF,qEAAqE;AACrE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAExD,2GAA2G;AAC3G,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAGrD,CAAA;AAED,8FAA8F;AAC9F,eAAO,MAAM,aAAa;;;;;;;;;;CAA+B,CAAA;AACzD,8EAA8E;AAC9E,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA;AAC1E,gFAAgF;AAChF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA;AAE1E,qFAAqF;AACrF,eAAO,MAAM,4BAA4B,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,eAAe,CAAC,WAAW,CAEjG,CAAA;AAED,+EAA+E;AAC/E,eAAO,MAAM,4BAA4B,GAAI,OAAO,OAAO,KAAG,eAAe,CAAC,WAAW,CAAC,GAAG,SAE5F,CAAA"}

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

@@ -1,4 +1,3 @@
-import type { Payload } from '@xyo-network/sdk';
 import { z } from 'zod/mini';
 /** Possible outcomes of adjudicating a slash request. */
 export declare const SlashOutcomes: readonly ["confirmed", "refuted", "indeterminate", "invalid"];
@@ -43,9 +42,133 @@ export declare const SlashAdjudicationFieldsZod: z.ZodMiniObject<{
 /** Fields represented by the slash adjudication contract. */
 export type SlashAdjudicationFields = z.infer<typeof SlashAdjudicationFieldsZod>;
 /** A slash adjudication payload — the on-chain record closing a report. */
-export type SlashAdjudication = Payload<SlashAdjudicationFields, SlashAdjudicationSchema>;
+export declare const SlashAdjudicationZod: z.ZodMiniObject<{
+    $version: z.ZodMiniOptional<z.ZodMiniNumberFormat<z.core.$ZodNumberFormats>>;
+    schema: z.ZodMiniLiteral<"network.xyo.chain.slash.adjudication" & {
+        readonly __schema: true;
+    }>;
+    claimant: z.ZodMiniOptional<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("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+    claimantCommit: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    from: 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("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+    outcome: z.ZodMiniLiteral<"confirmed" | "refuted" | "indeterminate" | "invalid">;
+    reason: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    request: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>;
+/** A slash adjudication payload — the on-chain record closing a report. */
+export type SlashAdjudication = z.infer<typeof SlashAdjudicationZod>;
 /** Type guard that checks if a value is a valid SlashAdjudication. */
-export declare const isSlashAdjudication: (x?: unknown) => x is SlashAdjudication;
+export declare const isSlashAdjudication: <T>(value: T) => value is T & {
+    schema: "network.xyo.chain.slash.adjudication" & {
+        readonly __schema: true;
+    };
+    from: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("@xyo-network/sdk").XyoQuantAddress;
+    outcome: "confirmed" | "refuted" | "indeterminate" | "invalid";
+    request: import("@ariestools/sdk").BrandedHash;
+    $version?: number | undefined;
+    claimant?: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("@xyo-network/sdk").XyoQuantAddress | undefined;
+    claimantCommit?: import("@ariestools/sdk").BrandedHash | undefined;
+    reason?: string | undefined;
+};
 /** Casts a value to SlashAdjudication or returns undefined if invalid. */
-export declare const asSlashAdjudication: import("@ariestools/sdk").AsTypeFunction<SlashAdjudication>;
+export declare const asSlashAdjudication: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.chain.slash.adjudication" & {
+            readonly __schema: true;
+        };
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        outcome: "confirmed" | "refuted" | "indeterminate" | "invalid";
+        request: import("@ariestools/sdk").BrandedHash;
+        $version?: number | undefined;
+        claimant?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress | undefined;
+        claimantCommit?: import("@ariestools/sdk").BrandedHash | undefined;
+        reason?: string | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.chain.slash.adjudication" & {
+            readonly __schema: true;
+        };
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        outcome: "confirmed" | "refuted" | "indeterminate" | "invalid";
+        request: import("@ariestools/sdk").BrandedHash;
+        $version?: number | undefined;
+        claimant?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress | undefined;
+        claimantCommit?: import("@ariestools/sdk").BrandedHash | undefined;
+        reason?: string | undefined;
+    };
+};
+/** Coerces a value to SlashAdjudication or returns undefined if invalid. */
+export declare const toSlashAdjudication: {
+    (value: unknown): {
+        schema: "network.xyo.chain.slash.adjudication" & {
+            readonly __schema: true;
+        };
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        outcome: "confirmed" | "refuted" | "indeterminate" | "invalid";
+        request: import("@ariestools/sdk").BrandedHash;
+        $version?: number | undefined;
+        claimant?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress | undefined;
+        claimantCommit?: import("@ariestools/sdk").BrandedHash | undefined;
+        reason?: string | undefined;
+    } | undefined;
+    (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
+        schema: "network.xyo.chain.slash.adjudication" & {
+            readonly __schema: true;
+        };
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        outcome: "confirmed" | "refuted" | "indeterminate" | "invalid";
+        request: import("@ariestools/sdk").BrandedHash;
+        $version?: number | undefined;
+        claimant?: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress | undefined;
+        claimantCommit?: import("@ariestools/sdk").BrandedHash | undefined;
+        reason?: string | undefined;
+    };
+};
 //# sourceMappingURL=SlashAdjudicationPayload.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SlashAdjudicationPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashAdjudicationPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,yDAAyD;AACzD,eAAO,MAAM,aAAa,+DAAgE,CAAA;AAE1F,mDAAmD;AACnD,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,MAAM,CAAC,CAAA;AAEvD,sCAAsC;AACtC,eAAO,MAAM,eAAe,yEAA2B,CAAA;AAEvD,yDAAyD;AACzD,eAAO,MAAM,uBAAuB;;CAAyD,CAAA;AAC7F,mDAAmD;AACnD,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAA;AAEpE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;iBAarC,CAAA;AAEF,6DAA6D;AAC7D,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEhF,2EAA2E;AAC3E,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,uBAAuB,EAAE,uBAAuB,CAAC,CAAA;AAEzF,sEAAsE;AACtE,eAAO,MAAM,mBAAmB,yCAG/B,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB,6DAA8C,CAAA"}
+{"version":3,"file":"SlashAdjudicationPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashAdjudicationPayload.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,yDAAyD;AACzD,eAAO,MAAM,aAAa,+DAAgE,CAAA;AAE1F,mDAAmD;AACnD,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,MAAM,CAAC,CAAA;AAEvD,sCAAsC;AACtC,eAAO,MAAM,eAAe,yEAA2B,CAAA;AAEvD,yDAAyD;AACzD,eAAO,MAAM,uBAAuB;;CAAyD,CAAA;AAC7F,mDAAmD;AACnD,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAA;AAEpE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;iBAarC,CAAA;AAEF,6DAA6D;AAC7D,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEhF,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;iBAA0F,CAAA;AAE3H,2EAA2E;AAC3E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,sEAAsE;AACtE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;AACrE,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA;AAC5F,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4D,CAAA"}

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

@@ -1,4 +1,3 @@
-import type { Payload } from '@xyo-network/sdk';
 import { z } from 'zod/mini';
 /** Schema identifier for slash challenge payloads. */
 export declare const SlashChallengeSchema: "network.xyo.chain.slash.challenge" & {
@@ -25,9 +24,91 @@ export declare const SlashChallengeFieldsZod: z.ZodMiniObject<{
 /** Fields represented by the slash challenge contract. */
 export type SlashChallengeFields = z.infer<typeof SlashChallengeFieldsZod>;
 /** A slash challenge payload — counter-evidence against a pending report. */
-export type SlashChallenge = Payload<SlashChallengeFields, SlashChallengeSchema>;
+export declare const SlashChallengeZod: z.ZodMiniObject<{
+    $version: z.ZodMiniOptional<z.ZodMiniNumberFormat<z.core.$ZodNumberFormats>>;
+    schema: z.ZodMiniLiteral<"network.xyo.chain.slash.challenge" & {
+        readonly __schema: true;
+    }>;
+    evidence: z.ZodMiniArray<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+    from: 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("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+    request: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+}, z.core.$strip>;
+/** A slash challenge payload — counter-evidence against a pending report. */
+export type SlashChallenge = z.infer<typeof SlashChallengeZod>;
 /** Type guard that checks if a value is a valid SlashChallenge. */
-export declare const isSlashChallenge: (x?: unknown) => x is SlashChallenge;
+export declare const isSlashChallenge: <T>(value: T) => value is T & {
+    schema: "network.xyo.chain.slash.challenge" & {
+        readonly __schema: true;
+    };
+    evidence: import("@ariestools/sdk").BrandedHash[];
+    from: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("@xyo-network/sdk").XyoQuantAddress;
+    request: import("@ariestools/sdk").BrandedHash;
+    $version?: number | undefined;
+};
 /** Casts a value to SlashChallenge or returns undefined if invalid. */
-export declare const asSlashChallenge: import("@ariestools/sdk").AsTypeFunction<SlashChallenge>;
+export declare const asSlashChallenge: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.chain.slash.challenge" & {
+            readonly __schema: true;
+        };
+        evidence: import("@ariestools/sdk").BrandedHash[];
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        request: import("@ariestools/sdk").BrandedHash;
+        $version?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.chain.slash.challenge" & {
+            readonly __schema: true;
+        };
+        evidence: import("@ariestools/sdk").BrandedHash[];
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        request: import("@ariestools/sdk").BrandedHash;
+        $version?: number | undefined;
+    };
+};
+/** Coerces a value to SlashChallenge or returns undefined if invalid. */
+export declare const toSlashChallenge: {
+    (value: unknown): {
+        schema: "network.xyo.chain.slash.challenge" & {
+            readonly __schema: true;
+        };
+        evidence: import("@ariestools/sdk").BrandedHash[];
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        request: import("@ariestools/sdk").BrandedHash;
+        $version?: number | undefined;
+    } | undefined;
+    (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
+        schema: "network.xyo.chain.slash.challenge" & {
+            readonly __schema: true;
+        };
+        evidence: import("@ariestools/sdk").BrandedHash[];
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        request: import("@ariestools/sdk").BrandedHash;
+        $version?: number | undefined;
+    };
+};
 //# sourceMappingURL=SlashChallengePayload.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SlashChallengePayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashChallengePayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,sDAAsD;AACtD,eAAO,MAAM,oBAAoB;;CAAsD,CAAA;AACvF,gDAAgD;AAChD,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;iBAOlC,CAAA;AAEF,0DAA0D;AAC1D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE1E,6EAA6E;AAC7E,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,oBAAoB,EAAE,oBAAoB,CAAC,CAAA;AAEhF,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,sCAAoF,CAAA;AAEjH,uEAAuE;AACvE,eAAO,MAAM,gBAAgB,0DAA2C,CAAA"}
+{"version":3,"file":"SlashChallengePayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashChallengePayload.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,sDAAsD;AACtD,eAAO,MAAM,oBAAoB;;CAAsD,CAAA;AACvF,gDAAgD;AAChD,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;iBAOlC,CAAA;AAEF,0DAA0D;AAC1D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE1E,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;iBAAoF,CAAA;AAElH,6EAA6E;AAC7E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,mEAAmE;AACnE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;CAAkC,CAAA;AAC/D,uEAAuE;AACvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsD,CAAA;AACnF,yEAAyE;AACzE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsD,CAAA"}

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

@@ -1,4 +1,3 @@
-import type { Payload } from '@xyo-network/sdk';
 import { z } from 'zod/mini';
 /** Schema identifier for slash commit payloads. */
 export declare const SlashCommitSchema: "network.xyo.chain.slash.commit" & {
@@ -27,9 +26,85 @@ export declare const SlashCommitFieldsZod: z.ZodMiniObject<{
 /** Fields represented by the slash commit contract. */
 export type SlashCommitFields = z.infer<typeof SlashCommitFieldsZod>;
 /** A slash commit payload — reserves a report before its evidence is public. */
-export type SlashCommit = Payload<SlashCommitFields, SlashCommitSchema>;
+export declare const SlashCommitZod: z.ZodMiniObject<{
+    $version: z.ZodMiniOptional<z.ZodMiniNumberFormat<z.core.$ZodNumberFormats>>;
+    schema: z.ZodMiniLiteral<"network.xyo.chain.slash.commit" & {
+        readonly __schema: true;
+    }>;
+    commitment: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+    from: 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("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+}, z.core.$strip>;
+/** A slash commit payload — reserves a report before its evidence is public. */
+export type SlashCommit = z.infer<typeof SlashCommitZod>;
 /** Type guard that checks if a value is a valid SlashCommit. */
-export declare const isSlashCommit: (x?: unknown) => x is SlashCommit;
+export declare const isSlashCommit: <T>(value: T) => value is T & {
+    schema: "network.xyo.chain.slash.commit" & {
+        readonly __schema: true;
+    };
+    commitment: import("@ariestools/sdk").BrandedHash;
+    from: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | import("@xyo-network/sdk").XyoQuantAddress;
+    $version?: number | undefined;
+};
 /** Casts a value to SlashCommit or returns undefined if invalid. */
-export declare const asSlashCommit: import("@ariestools/sdk").AsTypeFunction<SlashCommit>;
+export declare const asSlashCommit: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.chain.slash.commit" & {
+            readonly __schema: true;
+        };
+        commitment: import("@ariestools/sdk").BrandedHash;
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        $version?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.chain.slash.commit" & {
+            readonly __schema: true;
+        };
+        commitment: import("@ariestools/sdk").BrandedHash;
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        $version?: number | undefined;
+    };
+};
+/** Coerces a value to SlashCommit or returns undefined if invalid. */
+export declare const toSlashCommit: {
+    (value: unknown): {
+        schema: "network.xyo.chain.slash.commit" & {
+            readonly __schema: true;
+        };
+        commitment: import("@ariestools/sdk").BrandedHash;
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        $version?: number | undefined;
+    } | undefined;
+    (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
+        schema: "network.xyo.chain.slash.commit" & {
+            readonly __schema: true;
+        };
+        commitment: import("@ariestools/sdk").BrandedHash;
+        from: (Lowercase<string> & {
+            readonly __hex: true;
+        } & {
+            readonly __address: true;
+        }) | import("@xyo-network/sdk").XyoQuantAddress;
+        $version?: number | undefined;
+    };
+};
 //# sourceMappingURL=SlashCommitPayload.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SlashCommitPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashCommitPayload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAI/C,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,mDAAmD;AACnD,eAAO,MAAM,iBAAiB;;CAAmD,CAAA;AACjF,6CAA6C;AAC7C,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAExD;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB;;;;;;;iBAK/B,CAAA;AAEF,uDAAuD;AACvD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,gFAAgF;AAChF,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAA;AAEvE,gEAAgE;AAChE,eAAO,MAAM,aAAa,mCAA2E,CAAA;AAErG,oEAAoE;AACpE,eAAO,MAAM,aAAa,uDAAwC,CAAA"}
+{"version":3,"file":"SlashCommitPayload.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/protocol-model/payload/slash/SlashCommitPayload.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAE5B,mDAAmD;AACnD,eAAO,MAAM,iBAAiB;;CAAmD,CAAA;AACjF,6CAA6C;AAC7C,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAExD;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB;;;;;;;iBAK/B,CAAA;AAEF,uDAAuD;AACvD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEpE,gFAAgF;AAChF,eAAO,MAAM,cAAc;;;;;;;;;;;iBAA8E,CAAA;AAEzG,gFAAgF;AAChF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAExD,gEAAgE;AAChE,eAAO,MAAM,aAAa;;;;;;;;;;;CAA+B,CAAA;AACzD,oEAAoE;AACpE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA;AAC1E,sEAAsE;AACtE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA"}