@xyo-network/xl1-rpc 1.16.8 → 1.16.10

package/dist/node/types/schema/RewardsTotalViewerRpcSchemas.d.ts

@@ -6,23 +6,19 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
                 steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodNumber;
+                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>;
             }, z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
                 steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodNumber;
+                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
@@ -36,23 +32,19 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
                 steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodNumber;
+                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>;
             }, z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
                 steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodNumber;
+                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
@@ -66,23 +58,19 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
                 steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodNumber;
+                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>;
             }, z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
                 steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodNumber;
+                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
@@ -96,23 +84,19 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
                 steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodNumber;
+                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>;
             }, z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
                 steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodNumber;
+                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {
@@ -126,23 +110,19 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
                 steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodNumber;
+                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>;
             }, z.core.$strip>>], null>;
             to: z.ZodTuple<[z.ZodOptional<z.ZodObject<{
                 positions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 range: z.ZodOptional<z.ZodTuple<[z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").BlockNumber, number>>], null>>;
                 steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodNumber;
+                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                     step: z.ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>>;
+                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>>;
             }, z.core.$strip>>], null>;
         };
         result: {

package/dist/node/types/schema/RewardsTotalViewerRpcSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RewardsTotalViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsTotalViewerRpcSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA"}
+{"version":3,"file":"RewardsTotalViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsTotalViewerRpcSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA"}

package/dist/node/types/schema/StepViewerRpcSchemas.d.ts

@@ -3,11 +3,11 @@ export declare const StepViewerRpcSchemas: {
     randomizer: {
         params: {
             from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
         };
@@ -19,11 +19,11 @@ export declare const StepViewerRpcSchemas: {
     stake: {
         params: {
             from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
         };
@@ -35,35 +35,27 @@ export declare const StepViewerRpcSchemas: {
     stakers: {
         params: {
             from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
         };
         result: {
-            from: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, unknown>>>;
-            to: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, unknown>>>;
+            from: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
+            to: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
         };
     };
     weight: {
         params: {
             from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
         };
@@ -75,11 +67,11 @@ export declare const StepViewerRpcSchemas: {
     positionCount: {
         params: {
             from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
         };
@@ -91,11 +83,11 @@ export declare const StepViewerRpcSchemas: {
     positions: {
         params: {
             from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
         };
@@ -105,48 +97,32 @@ export declare const StepViewerRpcSchemas: {
                 addBlock: z.ZodNumber;
                 id: z.ZodNumber;
                 removeBlock: z.ZodNumber;
-                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>;
-                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>;
+                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>;
+                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>;
                 withdrawBlock: z.ZodNumber;
             }, z.z.core.$strip>, z.ZodTransform<{
                 addBlock: number;
                 amount: import("@xylabs/hex").Hex;
                 id: number;
                 removeBlock: number;
-                staked: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>;
-                staker: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>;
+                staked: import("@xylabs/hex").Address;
+                staker: import("@xylabs/hex").Address;
                 withdrawBlock: number;
             }, {
                 amount: bigint;
                 addBlock: number;
                 id: number;
                 removeBlock: number;
-                staked: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>;
-                staker: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>;
+                staked: import("@xylabs/hex").Address;
+                staker: import("@xylabs/hex").Address;
                 withdrawBlock: number;
             }>>>;
             to: z.ZodArray<z.ZodPipe<z.ZodObject<{
                 addBlock: z.ZodNumber;
                 id: z.ZodNumber;
                 removeBlock: z.ZodNumber;
-                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>;
-                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>;
+                staked: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>;
+                staker: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>;
                 withdrawBlock: z.ZodNumber;
                 amount: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
             }, z.z.core.$strip>, z.ZodTransform<{
@@ -154,23 +130,15 @@ export declare const StepViewerRpcSchemas: {
                 amount: import("@xyo-network/xl1-protocol").AttoXL1;
                 id: import("@xyo-network/xl1-protocol").PositionId;
                 removeBlock: number;
-                staked: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>;
-                staker: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>;
+                staked: import("@xylabs/hex").Address;
+                staker: import("@xylabs/hex").Address;
                 withdrawBlock: number;
             }, {
                 addBlock: number;
                 id: number;
                 removeBlock: number;
-                staked: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>;
-                staker: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>;
+                staked: import("@xylabs/hex").Address;
+                staker: import("@xylabs/hex").Address;
                 withdrawBlock: number;
                 amount: import("@xylabs/hex").Hex;
             }>>>;
@@ -179,11 +147,11 @@ export declare const StepViewerRpcSchemas: {
     stakerCount: {
         params: {
             from: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
             to: z.ZodTuple<[z.ZodObject<{
-                block: z.ZodNumber;
+                block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol").XL1BlockNumber, number>>;
                 step: z.ZodNumber;
             }, z.z.core.$strip>], null>;
         };

package/dist/node/types/schema/StepViewerRpcSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StepViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/StepViewerRpcSchemas.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAA;AAQnB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEa,CAAA"}
+{"version":3,"file":"StepViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/StepViewerRpcSchemas.ts"],"names":[],"mappings":"AAIA,OAAO,CAAC,MAAM,KAAK,CAAA;AAMnB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEa,CAAA"}

package/dist/node/types/schema/TimeSyncViewerRpcSchema.d.ts

@@ -0,0 +1,58 @@
+import * as z from 'zod';
+export declare const TimeSyncViewerRpcSchemas: {
+    timeSyncViewer_convertTime: {
+        params: {
+            from: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>, z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>, z.ZodNumber], null>;
+            to: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>, z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>, z.ZodNumber], null>;
+        };
+        result: {
+            from: z.ZodNumber;
+            to: z.ZodNumber;
+        };
+    };
+    timeSyncViewer_currentTime: {
+        params: {
+            from: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>], null>;
+            to: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>], null>;
+        };
+        result: {
+            from: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>, z.ZodNumber], null>;
+            to: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>, z.ZodNumber], null>;
+        };
+    };
+    timeSyncViewer_currentTimeAndHash: {
+        params: {
+            from: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>], null>;
+            to: z.ZodTuple<[z.ZodUnion<readonly [z.ZodLiteral<"xl1">, z.ZodLiteral<"epoch">, z.ZodLiteral<"ethereum">]>], null>;
+        };
+        result: {
+            from: z.ZodTuple<[z.ZodNumber, z.ZodNullable<z.ZodString>], null>;
+            to: z.ZodTuple<[z.ZodNumber, z.ZodNullable<z.ZodString>], null>;
+        };
+    };
+    timeSyncViewer_currentTimePayload: {
+        params: {
+            from: z.ZodTuple<[], null>;
+            to: z.ZodTuple<[], null>;
+        };
+        result: {
+            from: z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.time">;
+                xl1: z.ZodOptional<z.ZodNumber>;
+                xl1Hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+                ethereum: z.ZodOptional<z.ZodNumber>;
+                ethereumHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+                epoch: z.ZodNumber;
+            }, z.core.$strip>;
+            to: z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.time">;
+                xl1: z.ZodOptional<z.ZodNumber>;
+                xl1Hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+                ethereum: z.ZodOptional<z.ZodNumber>;
+                ethereumHash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
+                epoch: z.ZodNumber;
+            }, z.core.$strip>;
+        };
+    };
+};
+//# sourceMappingURL=TimeSyncViewerRpcSchema.d.ts.map

package/dist/node/types/schema/TimeSyncViewerRpcSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimeSyncViewerRpcSchema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/TimeSyncViewerRpcSchema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCgB,CAAA"}

package/dist/node/types/schema/XyoRunnerRpcSchemas.d.ts

@@ -4,17 +4,13 @@ export declare const XyoRunnerRpcSchemas: {
         params: {
             to: z.ZodTuple<[z.ZodTuple<[z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.boundwitness">;
-                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
                 payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
                 payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
                     __schema: true;
                 }, string>>]>>;
                 previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
                 $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
                 $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
                 _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -38,17 +34,13 @@ export declare const XyoRunnerRpcSchemas: {
             }, z.core.$strict>>], null>], null>;
             from: z.ZodTuple<[z.ZodTuple<[z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.boundwitness">;
-                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
                 payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
                 payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
                     __schema: true;
                 }, string>>]>>;
                 previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
                 $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
                 $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
                 _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;

package/dist/node/types/schema/XyoRunnerRpcSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"XyoRunnerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoRunnerRpcSchemas.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWgB,CAAA"}
+{"version":3,"file":"XyoRunnerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoRunnerRpcSchemas.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWgB,CAAA"}

package/dist/node/types/schema/XyoSignerRpcSchemas.d.ts

@@ -6,29 +6,21 @@ export declare const XyoSignerRpcSchemas: {
             readonly from: z.ZodOptional<z.ZodArray<z.ZodAny>>;
         };
         readonly result: {
-            readonly to: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>;
-            readonly from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                readonly __address: true;
-            }>, string>>;
+            readonly to: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>;
+            readonly from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>;
         };
     };
     readonly xyoSigner_signTransaction: {
         readonly params: {
             readonly to: z.ZodTuple<[z.ZodTuple<[z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.boundwitness">;
-                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
                 payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
                 payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
                     __schema: true;
                 }, string>>]>>;
                 previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
                 $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
                 $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
                 _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -52,17 +44,13 @@ export declare const XyoSignerRpcSchemas: {
             }, z.core.$strict>>], null>], null>;
             readonly from: z.ZodTuple<[z.ZodTuple<[z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.boundwitness">;
-                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
                 payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
                 payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
                     __schema: true;
                 }, string>>]>>;
                 previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
                 $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
                 $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
                 _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -88,17 +76,13 @@ export declare const XyoSignerRpcSchemas: {
         readonly result: {
             readonly to: z.ZodTuple<[z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.boundwitness">;
-                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
                 payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
                 payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
                     __schema: true;
                 }, string>>]>>;
                 previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
                 $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
                 $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
                 _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -122,17 +106,13 @@ export declare const XyoSignerRpcSchemas: {
             }, z.core.$strict>>], null>;
             readonly from: z.ZodPipe<z.ZodTuple<[z.ZodObject<{
                 schema: z.ZodLiteral<"network.xyo.boundwitness">;
-                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
                 payload_hashes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
                 payload_schemas: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string & {
                     __schema: true;
                 }, string>>]>>;
                 previous_hashes: z.ZodArray<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>>;
-                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>, string>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Address, string>>>;
                 $sourceQuery: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
                 $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodNull]>>;
                 _hash: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hash, string>>>;
@@ -155,9 +135,7 @@ export declare const XyoSignerRpcSchemas: {
                 }, string>>]>;
             }, z.core.$strict>>], null>, z.ZodTransform<import("@xyo-network/xl1-protocol").HydratedTransactionWithStorageMeta<import("@xyo-network/xl1-protocol").TransactionBoundWitness, import("@xyo-network/payload-model").Payload>, [{
                 schema: "network.xyo.boundwitness";
-                addresses: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }>[];
+                addresses: import("@xylabs/hex").Address[];
                 payload_hashes: import("@xylabs/hex").Hash[];
                 payload_schemas: (string | (string & {
                     __schema: true;
@@ -174,9 +152,7 @@ export declare const XyoSignerRpcSchemas: {
                 };
                 chain: import("@xyo-network/xl1-protocol").ChainId;
                 from: import("@xyo-network/xl1-protocol").ChainId;
-                $destination?: import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
-                    readonly __address: true;
-                }> | undefined;
+                $destination?: import("@xylabs/hex").Address | undefined;
                 $sourceQuery?: import("@xylabs/hex").Hash | undefined;
                 _hash?: import("@xylabs/hex").Hash | undefined;
                 _dataHash?: import("@xylabs/hex").Hash | undefined;

package/dist/node/types/schema/XyoSignerRpcSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"XyoSignerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoSignerRpcSchemas.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqByB,CAAA"}
+{"version":3,"file":"XyoSignerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoSignerRpcSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AASvB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqByB,CAAA"}