@xyo-network/xl1-rpc 3.0.0 → 3.0.2

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

@@ -1,501 +0,0 @@
-import { z } from 'zod';
-/** StakeViewerRpcSchemas constant. */
-export declare const StakeViewerRpcSchemas: {
-    stakeViewer_minWithdrawalBlocks: {
-        params: {
-            to: z.ZodDefault<z.ZodTuple<[], null>>;
-            from: z.ZodDefault<z.ZodTuple<[], null>>;
-        };
-        result: {
-            to: z.ZodNumber;
-            from: z.ZodNumber;
-        };
-    };
-    stakeViewer_rewardsContract: {
-        params: {
-            to: z.ZodDefault<z.ZodTuple<[], null>>;
-            from: z.ZodDefault<z.ZodTuple<[], null>>;
-        };
-        result: {
-            to: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-            from: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-        };
-    };
-    stakeViewer_stakeById: {
-        params: {
-            to: z.ZodTuple<[z.ZodNumber], null>;
-            from: z.ZodTuple<[z.ZodNumber], null>;
-        };
-        result: {
-            to: z.ZodPipe<z.ZodObject<{
-                amount: import("zod/mini").ZodMiniBigInt<bigint>;
-                addBlock: z.ZodNumber;
-                id: z.ZodNumber;
-                removeBlock: z.ZodNumber;
-                staked: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                staker: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                withdrawBlock: z.ZodNumber;
-            }, z.core.$strip>, z.ZodTransform<{
-                addBlock: number;
-                amount: import("@xylabs/sdk-js").BrandedHex;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-            }, {
-                amount: bigint;
-                addBlock: number;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-            }>>;
-            from: z.ZodPipe<z.ZodObject<{
-                addBlock: z.ZodNumber;
-                id: z.ZodNumber;
-                removeBlock: z.ZodNumber;
-                staked: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                staker: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                withdrawBlock: z.ZodNumber;
-                amount: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
-            }, z.core.$strip>, z.ZodTransform<{
-                addBlock: number;
-                amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-                id: import("@xyo-network/xl1-protocol-lib").PositionId;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-            }, {
-                addBlock: number;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-                amount: import("@xylabs/sdk-js").BrandedHex;
-            }>>;
-        };
-    };
-    stakeViewer_stakeByStaker: {
-        params: {
-            to: z.ZodTuple<[import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>, z.ZodNumber], null>;
-            from: z.ZodTuple<[import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>, z.ZodNumber], null>;
-        };
-        result: {
-            to: z.ZodPipe<z.ZodObject<{
-                amount: import("zod/mini").ZodMiniBigInt<bigint>;
-                addBlock: z.ZodNumber;
-                id: z.ZodNumber;
-                removeBlock: z.ZodNumber;
-                staked: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                staker: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                withdrawBlock: z.ZodNumber;
-            }, z.core.$strip>, z.ZodTransform<{
-                addBlock: number;
-                amount: import("@xylabs/sdk-js").BrandedHex;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-            }, {
-                amount: bigint;
-                addBlock: number;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-            }>>;
-            from: z.ZodPipe<z.ZodObject<{
-                addBlock: z.ZodNumber;
-                id: z.ZodNumber;
-                removeBlock: z.ZodNumber;
-                staked: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                staker: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                withdrawBlock: z.ZodNumber;
-                amount: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
-            }, z.core.$strip>, z.ZodTransform<{
-                addBlock: number;
-                amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-                id: import("@xyo-network/xl1-protocol-lib").PositionId;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-            }, {
-                addBlock: number;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-                amount: import("@xylabs/sdk-js").BrandedHex;
-            }>>;
-        };
-    };
-    stakeViewer_stakesByStaker: {
-        params: {
-            to: z.ZodTuple<[import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>], null>;
-            from: z.ZodTuple<[import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>], null>;
-        };
-        result: {
-            to: z.ZodArray<z.ZodPipe<z.ZodObject<{
-                amount: import("zod/mini").ZodMiniBigInt<bigint>;
-                addBlock: z.ZodNumber;
-                id: z.ZodNumber;
-                removeBlock: z.ZodNumber;
-                staked: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                staker: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                withdrawBlock: z.ZodNumber;
-            }, z.core.$strip>, z.ZodTransform<{
-                addBlock: number;
-                amount: import("@xylabs/sdk-js").BrandedHex;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-            }, {
-                amount: bigint;
-                addBlock: number;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-            }>>>;
-            from: z.ZodArray<z.ZodPipe<z.ZodObject<{
-                addBlock: z.ZodNumber;
-                id: z.ZodNumber;
-                removeBlock: z.ZodNumber;
-                staked: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                staker: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                withdrawBlock: z.ZodNumber;
-                amount: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
-            }, z.core.$strip>, z.ZodTransform<{
-                addBlock: number;
-                amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-                id: import("@xyo-network/xl1-protocol-lib").PositionId;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-            }, {
-                addBlock: number;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-                amount: import("@xylabs/sdk-js").BrandedHex;
-            }>>>;
-        };
-    };
-    stakeViewer_stakesByStaked: {
-        params: {
-            to: z.ZodTuple<[import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>], null>;
-            from: z.ZodTuple<[import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>], null>;
-        };
-        result: {
-            to: z.ZodArray<z.ZodPipe<z.ZodObject<{
-                amount: import("zod/mini").ZodMiniBigInt<bigint>;
-                addBlock: z.ZodNumber;
-                id: z.ZodNumber;
-                removeBlock: z.ZodNumber;
-                staked: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                staker: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                withdrawBlock: z.ZodNumber;
-            }, z.core.$strip>, z.ZodTransform<{
-                addBlock: number;
-                amount: import("@xylabs/sdk-js").BrandedHex;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-            }, {
-                amount: bigint;
-                addBlock: number;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-            }>>>;
-            from: z.ZodArray<z.ZodPipe<z.ZodObject<{
-                addBlock: z.ZodNumber;
-                id: z.ZodNumber;
-                removeBlock: z.ZodNumber;
-                staked: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                staker: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-                withdrawBlock: z.ZodNumber;
-                amount: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xylabs/sdk-js").BrandedHex, string>>;
-            }, z.core.$strip>, z.ZodTransform<{
-                addBlock: number;
-                amount: import("@xyo-network/xl1-protocol-lib").AttoXL1;
-                id: import("@xyo-network/xl1-protocol-lib").PositionId;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-            }, {
-                addBlock: number;
-                id: number;
-                removeBlock: number;
-                staked: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                staker: (Lowercase<string> & {
-                    readonly __hex: true;
-                } & {
-                    readonly __address: true;
-                }) | import("@xyo-network/sdk-js").XyoQuantAddress;
-                withdrawBlock: number;
-                amount: import("@xylabs/sdk-js").BrandedHex;
-            }>>>;
-        };
-    };
-    stakeViewer_stakingTokenAddress: {
-        params: {
-            to: z.ZodDefault<z.ZodTuple<[], null>>;
-            from: z.ZodDefault<z.ZodTuple<[], null>>;
-        };
-        result: {
-            to: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-            from: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
-                readonly __hex: true;
-            } & {
-                readonly __address: true;
-            }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-js").XyoQuantAddress, string>>]>;
-        };
-    };
-};
-/** StakeViewerRpcSchemas type. */
-export type StakeViewerRpcSchemas = typeof StakeViewerRpcSchemas;
-//# sourceMappingURL=StakeViewerRpcSchemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"StakeViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/StakeViewerRpcSchemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,sCAAsC;AACtC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEgB,CAAA;AAElD,kCAAkC;AAClC,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAA"}

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

@@ -1,5 +0,0 @@
-/** NetworkStakingStepRewardsViewerRpcSchemas constant. */
-export declare const NetworkStakingStepRewardsViewerRpcSchemas: {};
-/** NetworkStakingStepRewardsViewerRpcSchemas type. */
-export type NetworkStakingStepRewardsViewerRpcSchemas = typeof NetworkStakingStepRewardsViewerRpcSchemas;
-//# sourceMappingURL=StepRewardsViewerRpcSchemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"StepRewardsViewerRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/StepRewardsViewerRpcSchemas.ts"],"names":[],"mappings":"AAGA,0DAA0D;AAC1D,eAAO,MAAM,yCAAyC,IAA0E,CAAA;AAEhI,sDAAsD;AACtD,MAAM,MAAM,yCAAyC,GAAG,OAAO,yCAAyC,CAAA"}