@xyo-network/xl1-rpc 1.11.0 → 1.12.0

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

@@ -1,91 +1,437 @@
-import type { Hex } from '@xylabs/hex';
+import type { Chain } from '@xyo-network/xl1-protocol';
 import { z } from 'zod';
-import type { XyoGatewayRpcMethodName } from '../XyoGatewayRpc.ts';
-import type { RpcSchemaMap } from './RpcSchemaMap.ts';
-export declare const ChainConnectionSchema: z.ZodObject<{
-    chainId: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<Hex, z.ZodTypeDef, Hex>]>>;
+export declare const ChainConnectionZod: z.ZodObject<{
+    chainId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Chain, Chain>]>>;
     name: z.ZodString;
     url: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    url: string;
-    chainId?: string | Hex | undefined;
-}, {
-    name: string;
-    url: string;
-    chainId?: string | Hex | undefined;
+}, z.core.$strip>;
+export declare const CaveatTypesZod: z.ZodEnum<{
+    chain: "chain";
+    expiration: "expiration";
+    filteredResponse: "filteredResponse";
+    rateLimit: "rateLimit";
 }>;
-export declare const CaveatTypesSchema: z.ZodEnum<["chain", "expiration", "filteredResponse", "rateLimit"]>;
-export declare const CaveatsSchema: z.ZodObject<{
-    type: z.ZodEnum<["chain", "expiration", "filteredResponse", "rateLimit"]>;
+export declare const CaveatsZod: z.ZodObject<{
+    type: z.ZodEnum<{
+        chain: "chain";
+        expiration: "expiration";
+        filteredResponse: "filteredResponse";
+        rateLimit: "rateLimit";
+    }>;
     value: z.ZodUnknown;
-}, "strip", z.ZodTypeAny, {
-    type: "chain" | "expiration" | "filteredResponse" | "rateLimit";
-    value?: unknown;
-}, {
-    type: "chain" | "expiration" | "filteredResponse" | "rateLimit";
-    value?: unknown;
-}>;
-export declare const PermissionSchema: z.ZodObject<{
+}, z.core.$strip>;
+export declare const PermissionZod: z.ZodObject<{
     capability: z.ZodString;
     caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<["chain", "expiration", "filteredResponse", "rateLimit"]>;
+        type: z.ZodEnum<{
+            chain: "chain";
+            expiration: "expiration";
+            filteredResponse: "filteredResponse";
+            rateLimit: "rateLimit";
+        }>;
         value: z.ZodUnknown;
-    }, "strip", z.ZodTypeAny, {
-        type: "chain" | "expiration" | "filteredResponse" | "rateLimit";
-        value?: unknown;
-    }, {
-        type: "chain" | "expiration" | "filteredResponse" | "rateLimit";
-        value?: unknown;
-    }>, "many">>;
+    }, z.core.$strip>>>;
     invoker: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    capability: string;
-    invoker: string;
-    caveats?: {
-        type: "chain" | "expiration" | "filteredResponse" | "rateLimit";
-        value?: unknown;
-    }[] | undefined;
-}, {
-    capability: string;
-    invoker: string;
-    caveats?: {
-        type: "chain" | "expiration" | "filteredResponse" | "rateLimit";
-        value?: unknown;
-    }[] | undefined;
-}>;
-export declare const InvokerPermissionSchema: z.ZodObject<{
+}, z.core.$strip>;
+export declare const InvokerPermissionZod: z.ZodObject<{
     capability: z.ZodString;
     caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<["chain", "expiration", "filteredResponse", "rateLimit"]>;
+        type: z.ZodEnum<{
+            chain: "chain";
+            expiration: "expiration";
+            filteredResponse: "filteredResponse";
+            rateLimit: "rateLimit";
+        }>;
         value: z.ZodUnknown;
-    }, "strip", z.ZodTypeAny, {
-        type: "chain" | "expiration" | "filteredResponse" | "rateLimit";
-        value?: unknown;
-    }, {
-        type: "chain" | "expiration" | "filteredResponse" | "rateLimit";
-        value?: unknown;
-    }>, "many">>;
+    }, z.core.$strip>>>;
     invoker: z.ZodString;
-} & {
     date: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    capability: string;
-    invoker: string;
-    date?: number | undefined;
-    caveats?: {
-        type: "chain" | "expiration" | "filteredResponse" | "rateLimit";
-        value?: unknown;
-    }[] | undefined;
-}, {
-    capability: string;
-    invoker: string;
-    date?: number | undefined;
-    caveats?: {
-        type: "chain" | "expiration" | "filteredResponse" | "rateLimit";
-        value?: unknown;
-    }[] | undefined;
-}>;
-export type ChainConnection = z.infer<typeof ChainConnectionSchema>;
-export declare const XyoGatewayRpcSchemas: RpcSchemaMap<XyoGatewayRpcMethodName>;
+}, z.core.$strip>;
+export type ChainConnection = z.infer<typeof ChainConnectionZod>;
+export declare const XyoGatewayRpcSchemas: {
+    xyoGateway_submitTransaction: {
+        params: {
+            from: z.ZodArray<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/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                payload_schemas: z.ZodArray<z.ZodString>;
+                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>, z.ZodNull]>>;
+                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+                nbf: z.ZodNumber;
+                exp: z.ZodNumber;
+                fees: z.ZodObject<{
+                    base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                }, z.core.$strip>;
+                chain: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
+                from: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
+                script: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                schema: z.ZodString;
+            }, z.core.$catchall<z.ZodAny>>>], null>>;
+            to: z.ZodArray<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/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                payload_schemas: z.ZodArray<z.ZodString>;
+                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>, z.ZodNull]>>;
+                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+                nbf: z.ZodNumber;
+                exp: z.ZodNumber;
+                fees: z.ZodObject<{
+                    base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                    priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                        readonly __hex: true;
+                    }>, unknown>>;
+                }, z.core.$strip>;
+                chain: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
+                from: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
+                script: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                schema: z.ZodString;
+            }, z.core.$catchall<z.ZodAny>>>], null>>;
+        };
+        result: {
+            from: z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.boundwitness">;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                payload_schemas: z.ZodArray<z.ZodString>;
+                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>, z.ZodNull]>>;
+                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+                block: z.ZodNumber;
+                chain: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
+                previous: z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>>;
+                protocol: z.ZodOptional<z.ZodNumber>;
+                step_hashes: z.ZodOptional<z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>>>;
+                $epoch: z.ZodNumber;
+            }, z.core.$strip>;
+            to: z.ZodObject<{
+                schema: z.ZodLiteral<"network.xyo.boundwitness">;
+                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                payload_schemas: z.ZodArray<z.ZodString>;
+                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>>;
+                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __address: true;
+                }>, string>>>;
+                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>>;
+                $signatures: z.ZodArray<z.ZodUnion<readonly [z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>, z.ZodNull]>>;
+                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, {
+                    readonly __hash: true;
+                }>>>>;
+                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+                block: z.ZodNumber;
+                chain: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
+                previous: z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>>;
+                protocol: z.ZodOptional<z.ZodNumber>;
+                step_hashes: z.ZodOptional<z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
+                    readonly __hex: true;
+                }>, unknown>>>>;
+                $epoch: z.ZodNumber;
+            }, z.core.$strip>;
+        };
+    };
+};
 //# sourceMappingURL=XyoGatewayRpcSchemas.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"XyoGatewayRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoGatewayRpcSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAA;AAElE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;EAIhC,CAAA;AAEF,eAAO,MAAM,iBAAiB,qEAAmE,CAAA;AAEjG,eAAO,MAAM,aAAa;;;;;;;;;EAGxB,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI3B,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA2D,CAAA;AAE/F,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,uBAAuB,CA6EtE,CAAA"}
+{"version":3,"file":"XyoGatewayRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoGatewayRpcSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAA;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAA;AAEF,eAAO,MAAM,cAAc;;;;;EAAmE,CAAA;AAE9F,eAAO,MAAM,UAAU;;;;;;;;iBAGrB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;iBAIxB,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;iBAAwD,CAAA;AAEzF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EgB,CAAA"}