@xyo-network/xl1-rpc 1.15.1 → 1.15.3

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

@@ -1,437 +0,0 @@
-import type { Chain } from '@xyo-network/xl1-protocol';
-import * as z from 'zod';
-export declare const ChainConnectionZod: z.ZodObject<{
-    chainId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Chain, Chain>]>>;
-    name: z.ZodString;
-    url: z.ZodString;
-}, z.core.$strip>;
-export declare const CaveatTypesZod: z.ZodEnum<{
-    chain: "chain";
-    expiration: "expiration";
-    filteredResponse: "filteredResponse";
-    rateLimit: "rateLimit";
-}>;
-export declare const CaveatsZod: z.ZodObject<{
-    type: z.ZodEnum<{
-        chain: "chain";
-        expiration: "expiration";
-        filteredResponse: "filteredResponse";
-        rateLimit: "rateLimit";
-    }>;
-    value: z.ZodUnknown;
-}, z.core.$strip>;
-export declare const PermissionZod: z.ZodObject<{
-    capability: z.ZodString;
-    caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            chain: "chain";
-            expiration: "expiration";
-            filteredResponse: "filteredResponse";
-            rateLimit: "rateLimit";
-        }>;
-        value: z.ZodUnknown;
-    }, z.core.$strip>>>;
-    invoker: z.ZodString;
-}, z.core.$strip>;
-export declare const InvokerPermissionZod: z.ZodObject<{
-    capability: z.ZodString;
-    caveats: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            chain: "chain";
-            expiration: "expiration";
-            filteredResponse: "filteredResponse";
-            rateLimit: "rateLimit";
-        }>;
-        value: z.ZodUnknown;
-    }, z.core.$strip>>>;
-    invoker: z.ZodString;
-    date: z.ZodOptional<z.ZodNumber>;
-}, 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 +0,0 @@
-{"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,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,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"}

package/dist/node/engine/rpcEngineFromProvider.d.ts

@@ -1,4 +0,0 @@
-import { JsonRpcEngine } from '@metamask/json-rpc-engine';
-import type { XyoConnection } from '@xyo-network/xl1-protocol';
-export declare const rpcEngineFromProvider: (provider: XyoConnection) => JsonRpcEngine;
-//# sourceMappingURL=rpcEngineFromProvider.d.ts.map

package/dist/node/engine/rpcEngineFromProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rpcEngineFromProvider.d.ts","sourceRoot":"","sources":["../../../src/engine/rpcEngineFromProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAEhF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAQ9D,eAAO,MAAM,qBAAqB,GAAI,UAAU,aAAa,kBA8C5D,CAAA"}

package/dist/node/engine/rpcMethodHandlersFromProvider.d.ts

@@ -1,4 +0,0 @@
-import type { XyoConnection } from '@xyo-network/xl1-protocol';
-import type { XyoProviderRpcMethodHandlers } from '../types/index.ts';
-export declare const rpcMethodHandlersFromProvider: (provider: XyoConnection) => XyoProviderRpcMethodHandlers;
-//# sourceMappingURL=rpcMethodHandlersFromProvider.d.ts.map

package/dist/node/engine/rpcMethodHandlersFromProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rpcMethodHandlersFromProvider.d.ts","sourceRoot":"","sources":["../../../src/engine/rpcMethodHandlersFromProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAE9D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAA;AAKrE,eAAO,MAAM,6BAA6B,GAAI,UAAU,aAAa,KAAG,4BASvE,CAAA"}

package/dist/node/provider/client/PermissionsStore/MemoryPermissionsStore.d.ts

@@ -1,11 +0,0 @@
-import type { Promisable } from '@xylabs/promise';
-import type { InvokerPermission, Permission } from '@xyo-network/xl1-protocol';
-import type { PermissionsStore } from './PermissionsStore.ts';
-export declare class MemoryPermissionsStore implements PermissionsStore {
-    private readonly _store;
-    getPermissions(): Promisable<InvokerPermission[]>;
-    requestPermissions(permissions: Permission[]): Promisable<boolean>;
-    revokePermissions(permissions: Permission[]): Promisable<boolean>;
-    private getKey;
-}
-//# sourceMappingURL=MemoryPermissionsStore.d.ts.map

package/dist/node/provider/client/PermissionsStore/MemoryPermissionsStore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MemoryPermissionsStore.d.ts","sourceRoot":"","sources":["../../../../../src/provider/client/PermissionsStore/MemoryPermissionsStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAE9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAE7D,qBAAa,sBAAuB,YAAW,gBAAgB;IAC7D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4C;IAEnE,cAAc,IAAI,UAAU,CAAC,iBAAiB,EAAE,CAAC;IAIjD,kBAAkB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC;IASlE,iBAAiB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC;IAQjE,OAAO,CAAC,MAAM;CAGf"}

package/dist/node/provider/client/PermissionsStore/PermissionsStore.d.ts

@@ -1,8 +0,0 @@
-import type { Promisable } from '@xylabs/promise';
-import type { InvokerPermission, Permission } from '@xyo-network/xl1-protocol';
-export interface PermissionsStore {
-    getPermissions(): Promisable<InvokerPermission[]>;
-    requestPermissions(permissions: Permission[]): Promisable<boolean>;
-    revokePermissions(permissions: Permission[]): Promisable<boolean>;
-}
-//# sourceMappingURL=PermissionsStore.d.ts.map

package/dist/node/provider/client/PermissionsStore/PermissionsStore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PermissionsStore.d.ts","sourceRoot":"","sources":["../../../../../src/provider/client/PermissionsStore/PermissionsStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAE9E,MAAM,WAAW,gBAAgB;IAC/B,cAAc,IAAI,UAAU,CAAC,iBAAiB,EAAE,CAAC,CAAA;IACjD,kBAAkB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;IAClE,iBAAiB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;CAClE"}

package/dist/node/provider/client/PermissionsStore/getPermissionsStoreFromTransport.d.ts

@@ -1,5 +0,0 @@
-import { type RpcTransport } from '../../../transport/index.ts';
-import type { XyoGatewayRpcSchemas } from '../../../types/index.ts';
-import type { PermissionsStore } from './PermissionsStore.ts';
-export declare const getPermissionsStoreFromTransport: (_transport: RpcTransport<typeof XyoGatewayRpcSchemas>) => PermissionsStore;
-//# sourceMappingURL=getPermissionsStoreFromTransport.d.ts.map

package/dist/node/provider/client/PermissionsStore/getPermissionsStoreFromTransport.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getPermissionsStoreFromTransport.d.ts","sourceRoot":"","sources":["../../../../../src/provider/client/PermissionsStore/getPermissionsStoreFromTransport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAE7D,eAAO,MAAM,gCAAgC,GAAI,YAAY,YAAY,CAAC,OAAO,oBAAoB,CAAC,KAAG,gBAOxG,CAAA"}

package/dist/node/provider/client/PermissionsStore/index.d.ts

@@ -1,4 +0,0 @@
-export * from './getPermissionsStoreFromTransport.ts';
-export * from './MemoryPermissionsStore.ts';
-export * from './PermissionsStore.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/node/provider/client/PermissionsStore/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/provider/client/PermissionsStore/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAA;AACrD,cAAc,6BAA6B,CAAA;AAC3C,cAAc,uBAAuB,CAAA"}

package/dist/node/provider/client/PermissionsStore/spec/MemoryPermissionsStore.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=MemoryPermissionsStore.spec.d.ts.map

package/dist/node/provider/client/PermissionsStore/spec/MemoryPermissionsStore.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MemoryPermissionsStore.spec.d.ts","sourceRoot":"","sources":["../../../../../../src/provider/client/PermissionsStore/spec/MemoryPermissionsStore.spec.ts"],"names":[],"mappings":""}

package/dist/node/transport/post-message/LegacyPostMessageRpcTransport.d.ts

@@ -1,15 +0,0 @@
-import type * as z from 'zod';
-import type { RpcSchemaMap, XyoGatewayRpcMethodName } from '../../types/index.ts';
-import type { RpcTransport } from '../RpcTransport.ts';
-/** @deprecated - now part of a client gateway */
-export declare class LegacyPostMessageRpcTransport implements RpcTransport<RpcSchemaMap<XyoGatewayRpcMethodName>> {
-    protected readonly destination?: string;
-    protected readonly schemas: RpcSchemaMap<XyoGatewayRpcMethodName>;
-    protected readonly sessionId?: string;
-    constructor(defaultDestination?: string, sessionId?: string);
-    sendRequest<TMethod extends keyof RpcSchemaMap<XyoGatewayRpcMethodName>>(method: TMethod, params?: z.input<RpcSchemaMap<XyoGatewayRpcMethodName>[TMethod]['params']['to']>): Promise<z.output<RpcSchemaMap<XyoGatewayRpcMethodName>[TMethod]['result']['from']>>;
-    private callRpc;
-}
-/** @deprecated - use LegacyPostMessageRpcTransport but rely on wallet release > 1.17.1 to handle the postMessage flow */
-export declare const PostMessageRpcTransport: typeof LegacyPostMessageRpcTransport;
-//# sourceMappingURL=LegacyPostMessageRpcTransport.d.ts.map

package/dist/node/transport/post-message/LegacyPostMessageRpcTransport.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LegacyPostMessageRpcTransport.d.ts","sourceRoot":"","sources":["../../../../src/transport/post-message/LegacyPostMessageRpcTransport.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAA;AAE7B,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAEjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAgBtD,iDAAiD;AACjD,qBAAa,6BAA8B,YAAW,YAAY,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC;IACvG,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IACvC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC,uBAAuB,CAAC,CAAA;IACjE,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;gBAEzB,kBAAkB,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;IAMrD,WAAW,CACf,OAAO,SAAS,MAAM,YAAY,CAAC,uBAAuB,CAAC,EAE3D,MAAM,EAAE,OAAO,EACf,MAAM,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,GAC/E,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;YAKxE,OAAO;CAiEtB;AAED,yHAAyH;AAEzH,eAAO,MAAM,uBAAuB,sCAAgC,CAAA"}

package/dist/node/types/XyoGatewayRpc.d.ts

@@ -1,8 +0,0 @@
-import type { XyoGatewayProvider } from '@xyo-network/xl1-protocol';
-export type XyoGatewayMethodPrefix = 'xyoGateway';
-export type XyoGatewayMethodName = keyof Pick<XyoGatewayProvider, 'submitTransaction'>;
-export type XyoGatewayRpcMethodName = `${XyoGatewayMethodPrefix}_${XyoGatewayMethodName}`;
-export type XyoGatewayRpcMethodHandlers = {
-    [K in XyoGatewayMethodName as `${XyoGatewayMethodPrefix}_${K}`]: (params: Parameters<Exclude<XyoGatewayProvider[K], undefined>>) => ReturnType<Exclude<XyoGatewayProvider[K], undefined>>;
-};
-//# sourceMappingURL=XyoGatewayRpc.d.ts.map

package/dist/node/types/XyoGatewayRpc.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"XyoGatewayRpc.d.ts","sourceRoot":"","sources":["../../../src/types/XyoGatewayRpc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAEnE,MAAM,MAAM,sBAAsB,GAAG,YAAY,CAAA;AAEjD,MAAM,MAAM,oBAAoB,GAAG,MAAM,IAAI,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,CAAA;AAGtF,MAAM,MAAM,uBAAuB,GAAG,GAAG,sBAAsB,IAAI,oBAAoB,EAAE,CAAA;AAGzF,MAAM,MAAM,2BAA2B,GAAG;KACvC,CAAC,IAAI,oBAAoB,IAAI,GAAG,sBAAsB,IAAI,CAAC,EAAE,GAAG,CAC/D,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,KAC1D,UAAU,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;CAC3D,CAAA"}