@xyo-network/xl1-rpc 1.30.3 → 2.0.0

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

@@ -1,29 +1,29 @@
-import { z } from 'zod';
+import { z } from 'zod/mini';
 /** NetworkStakingStepRewardsTotalViewerRpcSchemas constant. */
 export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
     networkStakingStepRewardsTotalViewer_bonus: {
         params: {
-            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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            to: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
                 }, string>>>>;
             }, z.core.$strip>>], null>;
-            from: 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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
@@ -31,33 +31,33 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
             }, z.core.$strip>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
+            to: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
         };
     };
     networkStakingStepRewardsTotalViewer_claimed: {
         params: {
-            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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            to: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
                 }, string>>>>;
             }, z.core.$strip>>], null>;
-            from: 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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
@@ -65,33 +65,33 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
             }, z.core.$strip>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
+            to: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
         };
     };
     networkStakingStepRewardsTotalViewer_earned: {
         params: {
-            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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            to: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
                 }, string>>>>;
             }, z.core.$strip>>], null>;
-            from: 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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
@@ -99,33 +99,33 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
             }, z.core.$strip>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
+            to: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
         };
     };
     networkStakingStepRewardsTotalViewer_total: {
         params: {
-            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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            to: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
                 }, string>>>>;
             }, z.core.$strip>>], null>;
-            from: 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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
@@ -133,33 +133,33 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
             }, z.core.$strip>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
+            to: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
         };
     };
     networkStakingStepRewardsTotalViewer_unclaimed: {
         params: {
-            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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            to: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
                 }, string>>>>;
             }, z.core.$strip>>], null>;
-            from: 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-lib").BlockNumber, number>>, z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
-                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    block: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
-                    step: z.ZodNumber;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniOptional<import("zod").ZodObject<{
+                positions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber>>;
+                range: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>, import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").BlockNumber, number>>], null>>;
+                steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    block: import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<import("@xyo-network/xl1-protocol-lib").XL1BlockNumber, number>>;
+                    step: import("zod").ZodNumber;
                 }, z.core.$strip>>>;
-                stakers: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+                stakers: import("zod").ZodOptional<import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
                     readonly __hex: true;
                 } & {
                     readonly __address: true;
@@ -167,8 +167,8 @@ export declare const NetworkStakingStepRewardsTotalViewerRpcSchemas: {
             }, z.core.$strip>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
+            to: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
         };
     };
 };

package/dist/neutral/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,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,+DAA+D;AAC/D,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA;AAE3E,2DAA2D;AAC3D,MAAM,MAAM,8CAA8C,GAAG,OAAO,8CAA8C,CAAA"}
+{"version":3,"file":"RewardsTotalViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RewardsTotalViewerRpcSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,+DAA+D;AAC/D,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAA;AAE3E,2DAA2D;AAC3D,MAAM,MAAM,8CAA8C,GAAG,OAAO,8CAA8C,CAAA"}

package/dist/neutral/types/schema/RpcSchemaMap.d.ts

@@ -1,7 +1,7 @@
-import type { ZodType } from 'zod';
+import type { ZodMiniType } from 'zod/mini';
 interface SerializationTransform {
-    from: ZodType;
-    to: ZodType;
+    from: ZodMiniType;
+    to: ZodMiniType;
 }
 /** RequestResponseSchemas type. */
 export interface RequestResponseSchemas {

package/dist/neutral/types/schema/RpcSchemaMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RpcSchemaMap.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RpcSchemaMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AAElC,UAAU,sBAAsB;IAE9B,IAAI,EAAE,OAAO,CAAA;IAEb,EAAE,EAAE,OAAO,CAAA;CACZ;AAED,mCAAmC;AACnC,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,MAAM,EAAE,sBAAsB,CAAA;IAC9B;;OAEG;IACH,MAAM,EAAE,sBAAsB,CAAA;CAC/B;AAED,yBAAyB;AACzB,MAAM,MAAM,YAAY,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,IAAI,MAAM,CAChE,OAAO,EACP,sBAAsB,CACvB,CAAA"}
+{"version":3,"file":"RpcSchemaMap.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/RpcSchemaMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C,UAAU,sBAAsB;IAE9B,IAAI,EAAE,WAAW,CAAA;IAEjB,EAAE,EAAE,WAAW,CAAA;CAChB;AAED,mCAAmC;AACnC,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,MAAM,EAAE,sBAAsB,CAAA;IAC9B;;OAEG;IACH,MAAM,EAAE,sBAAsB,CAAA;CAC/B;AAED,yBAAyB;AACzB,MAAM,MAAM,YAAY,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,IAAI,MAAM,CAChE,OAAO,EACP,sBAAsB,CACvB,CAAA"}

package/dist/neutral/types/schema/StakeTotalsViewerRpcSchemas.d.ts

@@ -1,106 +1,106 @@
-import { z } from 'zod';
+import { z } from 'zod/mini';
 /** StakeTotalsViewerRpcSchemas constant. */
 export declare const StakeTotalsViewerRpcSchemas: {
     stakeTotalsViewer_active: {
         params: {
-            to: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>], null>>;
-            from: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>], null>>;
+            to: z.ZodMiniOptional<z.ZodMiniTuple<readonly [z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>>;
+            from: z.ZodMiniOptional<z.ZodMiniTuple<readonly [z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
+            to: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
         };
     };
     stakeTotalsViewer_activeByStaked: {
         params: {
-            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            to: z.ZodMiniTuple<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodOptional<z.ZodNumber>], null>;
-            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            }, string>>, z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodOptional<z.ZodNumber>], null>;
+            }, string>>, z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
+            to: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
         };
     };
     stakeTotalsViewer_activeByStaker: {
         params: {
-            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            to: z.ZodMiniTuple<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodOptional<z.ZodNumber>], null>;
-            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            }, string>>, z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodOptional<z.ZodNumber>], null>;
+            }, string>>, z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
+            to: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
         };
     };
     stakeTotalsViewer_pending: {
         params: {
-            to: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>], null>>;
-            from: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>], null>>;
+            to: z.ZodMiniOptional<z.ZodMiniTuple<readonly [z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>>;
+            from: z.ZodMiniOptional<z.ZodMiniTuple<readonly [z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
+            to: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
         };
     };
     stakeTotalsViewer_pendingByStaker: {
         params: {
-            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            to: z.ZodMiniTuple<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodOptional<z.ZodNumber>], null>;
-            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            }, string>>, z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodOptional<z.ZodNumber>], null>;
+            }, string>>, z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
+            to: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
         };
     };
     stakeTotalsViewer_withdrawn: {
         params: {
-            to: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>], null>>;
-            from: z.ZodOptional<z.ZodTuple<[z.ZodOptional<z.ZodNumber>], null>>;
+            to: z.ZodMiniOptional<z.ZodMiniTuple<readonly [z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>>;
+            from: z.ZodMiniOptional<z.ZodMiniTuple<readonly [z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
+            to: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
         };
     };
     stakeTotalsViewer_withdrawnByStaker: {
         params: {
-            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            to: z.ZodMiniTuple<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodOptional<z.ZodNumber>], null>;
-            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<Lowercase<string> & {
+            }, string>>, z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>;
+            from: z.ZodMiniTuple<readonly [z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<Lowercase<string> & {
                 readonly __hex: true;
             } & {
                 readonly __address: true;
-            }, string>>, z.ZodOptional<z.ZodNumber>], null>;
+            }, string>>, z.ZodMiniOptional<z.ZodMiniNumber<number>>], null>;
         };
         result: {
-            to: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
-            from: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/sdk-js").BrandedHex, string>>, z.ZodTransform<bigint, import("@xylabs/sdk-js").BrandedHex>>, z.ZodTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
+            to: z.ZodMiniPipe<z.ZodMiniBigInt<bigint>, z.ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, bigint>>;
+            from: z.ZodMiniPipe<z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<bigint, string>>, z.ZodMiniTransform<import("@xyo-network/xl1-protocol-lib").AttoXL1, bigint>>;
         };
     };
 };

package/dist/neutral/types/schema/StakeTotalsViewerRpcSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StakeTotalsViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/StakeTotalsViewerRpcSchemas.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,4CAA4C;AAC5C,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEgB,CAAA;AAExD,wCAAwC;AACxC,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAA"}
+{"version":3,"file":"StakeTotalsViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/StakeTotalsViewerRpcSchemas.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,4CAA4C;AAC5C,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEgB,CAAA;AAExD,wCAAwC;AACxC,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAA"}