@taqueria/protocol 0.16.0 → 0.19.2

package/SandboxAccountConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["SandboxAccountConfig.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as PublicKeyHash from '@taqueria/protocol/PublicKeyHash';\nimport { z } from 'zod';\n\nconst internalSchema = z.object({\n\tencryptedKey: z.string({ description: 'Sandbox Account Encrypted Key' }).min(1),\n\tpublicKeyHash: PublicKeyHash.schemas.schema.describe('Sandbox Account Public Key Hash'),\n\tsecretKey: z.string({ description: 'Sandbox Account Secret Key' }).min(1),\n}, { description: 'Sandbox Account Configuration' });\n\nexport const rawSchema = z.object({\n\tencryptedKey: z.string({ description: 'Sandbox Account Encrypted Key' }).min(1),\n\tpublicKeyHash: z.string({ description: 'Sandbox Account Public Key Hash' }).min(1),\n\tsecretKey: z.string({ description: 'Sandbox Account Secret Key' }).min(1),\n}, { description: 'Sandbox Account Configuration' });\n\ntype Input = z.infer<typeof internalSchema>;\n\ntype RawInput = z.infer<typeof rawSchema>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: 'The sandbox account configuration is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the sandbox account configuration',\n});\n\nexport type SandboxAccountConfig = z.infer<typeof generatedSchemas.schema>;\nexport type t = SandboxAccountConfig;\nexport const { create, of, make } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as SandboxAccountConfig),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAAA;AAAA;AAAA;AAAA,kBAAuB;AACvB,oBAA+B;AAC/B,iBAAkB;AAElB,IAAM,iBAAiB,aAAE,OAAO;AAAA,EAC/B,cAAc,aAAE,OAAO,EAAE,aAAa,gCAAgC,CAAC,EAAE,IAAI,CAAC;AAAA,EAC9E,eAA6B,sBAAQ,OAAO,SAAS,iCAAiC;AAAA,EACtF,WAAW,aAAE,OAAO,EAAE,aAAa,6BAA6B,CAAC,EAAE,IAAI,CAAC;AACzE,GAAG,EAAE,aAAa,gCAAgC,CAAC;AAE5C,IAAM,YAAY,aAAE,OAAO;AAAA,EACjC,cAAc,aAAE,OAAO,EAAE,aAAa,gCAAgC,CAAC,EAAE,IAAI,CAAC;AAAA,EAC9E,eAAe,aAAE,OAAO,EAAE,aAAa,kCAAkC,CAAC,EAAE,IAAI,CAAC;AAAA,EACjF,WAAW,aAAE,OAAO,EAAE,aAAa,6BAA6B,CAAC,EAAE,IAAI,CAAC;AACzE,GAAG,EAAE,aAAa,gCAAgC,CAAC;AAM5C,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAC,SAA4B;AAAA,EACjF;AAAA,EACA;AAAA,EACA,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAE7B,IAAMD,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAA2B;AAC7E;","names":["schemas","createType"]}

package/SandboxAccountConfig.mjs

@@ -0,0 +1,35 @@
+// SandboxAccountConfig.ts
+import createType from "@taqueria/protocol/Base";
+import * as PublicKeyHash from "@taqueria/protocol/PublicKeyHash";
+import { z } from "zod";
+var internalSchema = z.object({
+  encryptedKey: z.string({ description: "Sandbox Account Encrypted Key" }).min(1),
+  publicKeyHash: PublicKeyHash.schemas.schema.describe("Sandbox Account Public Key Hash"),
+  secretKey: z.string({ description: "Sandbox Account Secret Key" }).min(1)
+}, { description: "Sandbox Account Configuration" });
+var rawSchema = z.object({
+  encryptedKey: z.string({ description: "Sandbox Account Encrypted Key" }).min(1),
+  publicKeyHash: z.string({ description: "Sandbox Account Public Key Hash" }).min(1),
+  secretKey: z.string({ description: "Sandbox Account Secret Key" }).min(1)
+}, { description: "Sandbox Account Configuration" });
+var { schemas: generatedSchemas, factory } = createType({
+  rawSchema,
+  internalSchema,
+  parseErrMsg: "The sandbox account configuration is invalid",
+  unknownErrMsg: "Something went wrong trying to parse the sandbox account configuration"
+});
+var { create, of, make } = factory;
+var schemas2 = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+export {
+  create,
+  factory,
+  generatedSchemas,
+  make,
+  of,
+  rawSchema,
+  schemas2 as schemas
+};
+//# sourceMappingURL=SandboxAccountConfig.mjs.map

package/SandboxAccountConfig.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["SandboxAccountConfig.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as PublicKeyHash from '@taqueria/protocol/PublicKeyHash';\nimport { z } from 'zod';\n\nconst internalSchema = z.object({\n\tencryptedKey: z.string({ description: 'Sandbox Account Encrypted Key' }).min(1),\n\tpublicKeyHash: PublicKeyHash.schemas.schema.describe('Sandbox Account Public Key Hash'),\n\tsecretKey: z.string({ description: 'Sandbox Account Secret Key' }).min(1),\n}, { description: 'Sandbox Account Configuration' });\n\nexport const rawSchema = z.object({\n\tencryptedKey: z.string({ description: 'Sandbox Account Encrypted Key' }).min(1),\n\tpublicKeyHash: z.string({ description: 'Sandbox Account Public Key Hash' }).min(1),\n\tsecretKey: z.string({ description: 'Sandbox Account Secret Key' }).min(1),\n}, { description: 'Sandbox Account Configuration' });\n\ntype Input = z.infer<typeof internalSchema>;\n\ntype RawInput = z.infer<typeof rawSchema>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: 'The sandbox account configuration is invalid',\n\tunknownErrMsg: 'Something went wrong trying to parse the sandbox account configuration',\n});\n\nexport type SandboxAccountConfig = z.infer<typeof generatedSchemas.schema>;\nexport type t = SandboxAccountConfig;\nexport const { create, of, make } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as SandboxAccountConfig),\n};\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,YAAY,mBAAmB;AAC/B,SAAS,SAAS;AAElB,IAAM,iBAAiB,EAAE,OAAO;AAAA,EAC/B,cAAc,EAAE,OAAO,EAAE,aAAa,gCAAgC,CAAC,EAAE,IAAI,CAAC;AAAA,EAC9E,eAA6B,sBAAQ,OAAO,SAAS,iCAAiC;AAAA,EACtF,WAAW,EAAE,OAAO,EAAE,aAAa,6BAA6B,CAAC,EAAE,IAAI,CAAC;AACzE,GAAG,EAAE,aAAa,gCAAgC,CAAC;AAE5C,IAAM,YAAY,EAAE,OAAO;AAAA,EACjC,cAAc,EAAE,OAAO,EAAE,aAAa,gCAAgC,CAAC,EAAE,IAAI,CAAC;AAAA,EAC9E,eAAe,EAAE,OAAO,EAAE,aAAa,kCAAkC,CAAC,EAAE,IAAI,CAAC;AAAA,EACjF,WAAW,EAAE,OAAO,EAAE,aAAa,6BAA6B,CAAC,EAAE,IAAI,CAAC;AACzE,GAAG,EAAE,aAAa,gCAAgC,CAAC;AAM5C,IAAM,EAAE,SAAS,kBAAkB,QAAQ,IAAI,WAA4B;AAAA,EACjF;AAAA,EACA;AAAA,EACA,aAAa;AAAA,EACb,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAE7B,IAAMA,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAA2B;AAC7E;","names":["schemas"]}

package/SandboxConfig.d.ts

@@ -0,0 +1,543 @@
+import { z } from 'zod';
+export declare const rawSchema: z.ZodObject<{
+    label: z.ZodString;
+    rpcUrl: z.ZodString;
+    protocol: z.ZodString;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    plugin: z.ZodOptional<z.ZodString>;
+    accounts: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        default: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        default: string;
+    }, {
+        default: string;
+    }>, z.ZodRecord<z.ZodString, z.ZodObject<{
+        encryptedKey: z.ZodString;
+        publicKeyHash: z.ZodString;
+        secretKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        encryptedKey: string;
+        publicKeyHash: string;
+        secretKey: string;
+    }, {
+        encryptedKey: string;
+        publicKeyHash: string;
+        secretKey: string;
+    }>>]>>;
+    tzkt: z.ZodOptional<z.ZodObject<{
+        disableAutostartWithSandbox: z.ZodDefault<z.ZodBoolean>;
+        postgresqlPort: z.ZodDefault<z.ZodNumber>;
+        apiPort: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        disableAutostartWithSandbox: boolean;
+        postgresqlPort: number;
+        apiPort: number;
+    }, {
+        disableAutostartWithSandbox?: boolean | undefined;
+        postgresqlPort?: number | undefined;
+        apiPort?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    attributes?: Record<string, string | number | boolean> | undefined;
+    plugin?: string | undefined;
+    accounts?: {
+        default: string;
+    } | Record<string, {
+        encryptedKey: string;
+        publicKeyHash: string;
+        secretKey: string;
+    }> | undefined;
+    tzkt?: {
+        disableAutostartWithSandbox: boolean;
+        postgresqlPort: number;
+        apiPort: number;
+    } | undefined;
+    label: string;
+    rpcUrl: string;
+    protocol: string;
+}, {
+    attributes?: Record<string, string | number | boolean> | undefined;
+    plugin?: string | undefined;
+    accounts?: {
+        default: string;
+    } | Record<string, {
+        encryptedKey: string;
+        publicKeyHash: string;
+        secretKey: string;
+    }> | undefined;
+    tzkt?: {
+        disableAutostartWithSandbox?: boolean | undefined;
+        postgresqlPort?: number | undefined;
+        apiPort?: number | undefined;
+    } | undefined;
+    label: string;
+    rpcUrl: string;
+    protocol: string;
+}>;
+export declare const generatedSchemas: {
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    schema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
+        attributes?: Record<string, string | number | boolean> | undefined;
+        plugin?: (string & {
+            readonly __kind: any;
+        }) | undefined;
+        accounts?: Record<string, string | ({
+            encryptedKey: string;
+            publicKeyHash: string & {
+                readonly __kind: any;
+            };
+            secretKey: string;
+        } & {
+            readonly __kind: any;
+        })> | undefined;
+        tzkt?: {
+            disableAutostartWithSandbox: boolean;
+            postgresqlPort: number;
+            apiPort: number;
+        } | undefined;
+        label: string & {
+            readonly __kind: any;
+        };
+        rpcUrl: string & {
+            readonly __kind: any;
+        };
+        protocol: string & {
+            readonly __kind: any;
+        };
+    } & {
+        readonly __kind: any;
+    }, any>;
+}, factory: {
+    make: (input: {
+        attributes?: Record<string, string | number | boolean> | undefined;
+        plugin?: (string & {
+            readonly __kind: any;
+        }) | undefined;
+        accounts?: Record<string, string | ({
+            encryptedKey: string;
+            publicKeyHash: string & {
+                readonly __kind: any;
+            };
+            secretKey: string;
+        } & {
+            readonly __kind: any;
+        })> | undefined;
+        tzkt?: {
+            disableAutostartWithSandbox: boolean;
+            postgresqlPort: number;
+            apiPort: number;
+        } | undefined;
+        label: string & {
+            readonly __kind: any;
+        };
+        rpcUrl: string & {
+            readonly __kind: any;
+        };
+        protocol: string & {
+            readonly __kind: any;
+        };
+    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        attributes?: Record<string, string | number | boolean> | undefined;
+        plugin?: (string & {
+            readonly __kind: any;
+        }) | undefined;
+        accounts?: Record<string, string | ({
+            encryptedKey: string;
+            publicKeyHash: string & {
+                readonly __kind: any;
+            };
+            secretKey: string;
+        } & {
+            readonly __kind: any;
+        })> | undefined;
+        tzkt?: {
+            disableAutostartWithSandbox: boolean;
+            postgresqlPort: number;
+            apiPort: number;
+        } | undefined;
+        label: string & {
+            readonly __kind: any;
+        };
+        rpcUrl: string & {
+            readonly __kind: any;
+        };
+        protocol: string & {
+            readonly __kind: any;
+        };
+    } & {
+        readonly __kind: any;
+    }>;
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        attributes?: Record<string, string | number | boolean> | undefined;
+        plugin?: (string & {
+            readonly __kind: any;
+        }) | undefined;
+        accounts?: Record<string, string | ({
+            encryptedKey: string;
+            publicKeyHash: string & {
+                readonly __kind: any;
+            };
+            secretKey: string;
+        } & {
+            readonly __kind: any;
+        })> | undefined;
+        tzkt?: {
+            disableAutostartWithSandbox: boolean;
+            postgresqlPort: number;
+            apiPort: number;
+        } | undefined;
+        label: string & {
+            readonly __kind: any;
+        };
+        rpcUrl: string & {
+            readonly __kind: any;
+        };
+        protocol: string & {
+            readonly __kind: any;
+        };
+    } & {
+        readonly __kind: any;
+    }>;
+    create: (input: {
+        attributes?: Record<string, string | number | boolean> | undefined;
+        plugin?: string | undefined;
+        accounts?: {
+            default: string;
+        } | Record<string, {
+            encryptedKey: string;
+            publicKeyHash: string;
+            secretKey: string;
+        }> | undefined;
+        tzkt?: {
+            disableAutostartWithSandbox: boolean;
+            postgresqlPort: number;
+            apiPort: number;
+        } | undefined;
+        label: string;
+        rpcUrl: string;
+        protocol: string;
+    } | {
+        attributes?: Record<string, string | number | boolean> | undefined;
+        plugin?: (string & {
+            readonly __kind: any;
+        }) | undefined;
+        accounts?: Record<string, string | ({
+            encryptedKey: string;
+            publicKeyHash: string & {
+                readonly __kind: any;
+            };
+            secretKey: string;
+        } & {
+            readonly __kind: any;
+        })> | undefined;
+        tzkt?: {
+            disableAutostartWithSandbox: boolean;
+            postgresqlPort: number;
+            apiPort: number;
+        } | undefined;
+        label: string & {
+            readonly __kind: any;
+        };
+        rpcUrl: string & {
+            readonly __kind: any;
+        };
+        protocol: string & {
+            readonly __kind: any;
+        };
+    }) => {
+        attributes?: Record<string, string | number | boolean> | undefined;
+        plugin?: (string & {
+            readonly __kind: any;
+        }) | undefined;
+        accounts?: Record<string, string | ({
+            encryptedKey: string;
+            publicKeyHash: string & {
+                readonly __kind: any;
+            };
+            secretKey: string;
+        } & {
+            readonly __kind: any;
+        })> | undefined;
+        tzkt?: {
+            disableAutostartWithSandbox: boolean;
+            postgresqlPort: number;
+            apiPort: number;
+        } | undefined;
+        label: string & {
+            readonly __kind: any;
+        };
+        rpcUrl: string & {
+            readonly __kind: any;
+        };
+        protocol: string & {
+            readonly __kind: any;
+        };
+    } & {
+        readonly __kind: any;
+    };
+    from: (input: unknown) => {
+        attributes?: Record<string, string | number | boolean> | undefined;
+        plugin?: (string & {
+            readonly __kind: any;
+        }) | undefined;
+        accounts?: Record<string, string | ({
+            encryptedKey: string;
+            publicKeyHash: string & {
+                readonly __kind: any;
+            };
+            secretKey: string;
+        } & {
+            readonly __kind: any;
+        })> | undefined;
+        tzkt?: {
+            disableAutostartWithSandbox: boolean;
+            postgresqlPort: number;
+            apiPort: number;
+        } | undefined;
+        label: string & {
+            readonly __kind: any;
+        };
+        rpcUrl: string & {
+            readonly __kind: any;
+        };
+        protocol: string & {
+            readonly __kind: any;
+        };
+    } & {
+        readonly __kind: any;
+    };
+};
+export declare type SandboxConfig = z.infer<typeof generatedSchemas.schema>;
+export declare type t = SandboxConfig;
+export declare const create: (input: {
+    attributes?: Record<string, string | number | boolean> | undefined;
+    plugin?: string | undefined;
+    accounts?: {
+        default: string;
+    } | Record<string, {
+        encryptedKey: string;
+        publicKeyHash: string;
+        secretKey: string;
+    }> | undefined;
+    tzkt?: {
+        disableAutostartWithSandbox: boolean;
+        postgresqlPort: number;
+        apiPort: number;
+    } | undefined;
+    label: string;
+    rpcUrl: string;
+    protocol: string;
+} | {
+    attributes?: Record<string, string | number | boolean> | undefined;
+    plugin?: (string & {
+        readonly __kind: any;
+    }) | undefined;
+    accounts?: Record<string, string | ({
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } & {
+        readonly __kind: any;
+    })> | undefined;
+    tzkt?: {
+        disableAutostartWithSandbox: boolean;
+        postgresqlPort: number;
+        apiPort: number;
+    } | undefined;
+    label: string & {
+        readonly __kind: any;
+    };
+    rpcUrl: string & {
+        readonly __kind: any;
+    };
+    protocol: string & {
+        readonly __kind: any;
+    };
+}) => {
+    attributes?: Record<string, string | number | boolean> | undefined;
+    plugin?: (string & {
+        readonly __kind: any;
+    }) | undefined;
+    accounts?: Record<string, string | ({
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } & {
+        readonly __kind: any;
+    })> | undefined;
+    tzkt?: {
+        disableAutostartWithSandbox: boolean;
+        postgresqlPort: number;
+        apiPort: number;
+    } | undefined;
+    label: string & {
+        readonly __kind: any;
+    };
+    rpcUrl: string & {
+        readonly __kind: any;
+    };
+    protocol: string & {
+        readonly __kind: any;
+    };
+} & {
+    readonly __kind: any;
+}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+    attributes?: Record<string, string | number | boolean> | undefined;
+    plugin?: (string & {
+        readonly __kind: any;
+    }) | undefined;
+    accounts?: Record<string, string | ({
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } & {
+        readonly __kind: any;
+    })> | undefined;
+    tzkt?: {
+        disableAutostartWithSandbox: boolean;
+        postgresqlPort: number;
+        apiPort: number;
+    } | undefined;
+    label: string & {
+        readonly __kind: any;
+    };
+    rpcUrl: string & {
+        readonly __kind: any;
+    };
+    protocol: string & {
+        readonly __kind: any;
+    };
+} & {
+    readonly __kind: any;
+}>, make: (input: {
+    attributes?: Record<string, string | number | boolean> | undefined;
+    plugin?: (string & {
+        readonly __kind: any;
+    }) | undefined;
+    accounts?: Record<string, string | ({
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } & {
+        readonly __kind: any;
+    })> | undefined;
+    tzkt?: {
+        disableAutostartWithSandbox: boolean;
+        postgresqlPort: number;
+        apiPort: number;
+    } | undefined;
+    label: string & {
+        readonly __kind: any;
+    };
+    rpcUrl: string & {
+        readonly __kind: any;
+    };
+    protocol: string & {
+        readonly __kind: any;
+    };
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+    attributes?: Record<string, string | number | boolean> | undefined;
+    plugin?: (string & {
+        readonly __kind: any;
+    }) | undefined;
+    accounts?: Record<string, string | ({
+        encryptedKey: string;
+        publicKeyHash: string & {
+            readonly __kind: any;
+        };
+        secretKey: string;
+    } & {
+        readonly __kind: any;
+    })> | undefined;
+    tzkt?: {
+        disableAutostartWithSandbox: boolean;
+        postgresqlPort: number;
+        apiPort: number;
+    } | undefined;
+    label: string & {
+        readonly __kind: any;
+    };
+    rpcUrl: string & {
+        readonly __kind: any;
+    };
+    protocol: string & {
+        readonly __kind: any;
+    };
+} & {
+    readonly __kind: any;
+}>;
+export declare const schemas: {
+    schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
+        attributes?: Record<string, string | number | boolean> | undefined;
+        plugin?: (string & {
+            readonly __kind: any;
+        }) | undefined;
+        accounts?: Record<string, string | ({
+            encryptedKey: string;
+            publicKeyHash: string & {
+                readonly __kind: any;
+            };
+            secretKey: string;
+        } & {
+            readonly __kind: any;
+        })> | undefined;
+        tzkt?: {
+            disableAutostartWithSandbox: boolean;
+            postgresqlPort: number;
+            apiPort: number;
+        } | undefined;
+        label: string & {
+            readonly __kind: any;
+        };
+        rpcUrl: string & {
+            readonly __kind: any;
+        };
+        protocol: string & {
+            readonly __kind: any;
+        };
+    } & {
+        readonly __kind: any;
+    }, any>, {
+        attributes?: Record<string, string | number | boolean> | undefined;
+        plugin?: (string & {
+            readonly __kind: any;
+        }) | undefined;
+        accounts?: Record<string, string | ({
+            encryptedKey: string;
+            publicKeyHash: string & {
+                readonly __kind: any;
+            };
+            secretKey: string;
+        } & {
+            readonly __kind: any;
+        })> | undefined;
+        tzkt?: {
+            disableAutostartWithSandbox: boolean;
+            postgresqlPort: number;
+            apiPort: number;
+        } | undefined;
+        label: string & {
+            readonly __kind: any;
+        };
+        rpcUrl: string & {
+            readonly __kind: any;
+        };
+        protocol: string & {
+            readonly __kind: any;
+        };
+    } & {
+        readonly __kind: any;
+    }, any>;
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+};
+//# sourceMappingURL=SandboxConfig.d.ts.map

package/SandboxConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxConfig.d.ts","sourceRoot":"","sources":["SandboxConfig.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBpB,CAAC;AAkBH,eAAO,MAAiB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK/C,CAAC;AAEH,oBAAY,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AACpE,oBAAY,CAAC,GAAG,aAAa,CAAC;AAC9B,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC"}

package/SandboxConfig.js

@@ -0,0 +1,103 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// SandboxConfig.ts
+var SandboxConfig_exports = {};
+__export(SandboxConfig_exports, {
+  create: () => create,
+  factory: () => factory,
+  generatedSchemas: () => generatedSchemas,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema4,
+  schemas: () => schemas6
+});
+module.exports = __toCommonJS(SandboxConfig_exports);
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var EconomicalProtocolHash = __toESM(require("@taqueria/protocol/EconomicalProtocolHash"));
+var HumanReadableIdentifier = __toESM(require("@taqueria/protocol/HumanReadableIdentifier"));
+var SandboxAccountConfig = __toESM(require("@taqueria/protocol/SandboxAccountConfig"));
+var TzKt = __toESM(require("@taqueria/protocol/tzkt-config"));
+var Url = __toESM(require("@taqueria/protocol/Url"));
+var Verb = __toESM(require("@taqueria/protocol/Verb"));
+var import_zod = require("zod");
+var accountMapSchema = import_zod.z.record(
+  import_zod.z.union([
+    import_zod.z.string().nonempty(),
+    SandboxAccountConfig.schemas.schema
+  ])
+);
+var rawSchema4 = import_zod.z.object({
+  label: import_zod.z.string({ description: "Sandbox Label" }).min(1),
+  rpcUrl: import_zod.z.string({ description: "Sandbox RPC Url" }).min(5).url(),
+  protocol: import_zod.z.string({ description: "Sandbox Protocol Hash" }).min(8),
+  attributes: import_zod.z.record(
+    import_zod.z.union(
+      [import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()],
+      { description: "Sandbox Attribute" }
+    ),
+    { description: "Sandbox Attributes" }
+  ).optional(),
+  plugin: Verb.rawSchema.describe("Sandbox Plugin").optional(),
+  accounts: import_zod.z.union([
+    import_zod.z.object({ default: import_zod.z.string().min(1) }),
+    import_zod.z.record(SandboxAccountConfig.rawSchema)
+  ], { description: "Sandbox Accounts" }).optional(),
+  tzkt: TzKt.rawSchema.describe("TzKt config").optional()
+});
+var internalSchema = import_zod.z.object({
+  label: HumanReadableIdentifier.schemas.schema.describe("Sandbox Label"),
+  rpcUrl: Url.schemas.schema.describe("Sandbox RPC Url"),
+  protocol: EconomicalProtocolHash.schemas.schema.describe("Sandbox Protocol Hash"),
+  attributes: import_zod.z.record(
+    import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()]),
+    { description: "Sandbox Attributes" }
+  ).optional(),
+  plugin: Verb.schemas.schema.describe("Sandbox Plugin").optional(),
+  accounts: accountMapSchema.optional(),
+  tzkt: TzKt.rawSchema.describe("TzKt config").optional()
+}, { description: "Sandbox Configuration" });
+var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
+  rawSchema: rawSchema4,
+  internalSchema,
+  parseErrMsg: (value) => `${value} is not a valid sandbox configuration `,
+  unknownErrMsg: "Something went wrong trying to parse the sandbox configuration"
+});
+var { create, of, make } = factory;
+var schemas6 = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  factory,
+  generatedSchemas,
+  make,
+  of,
+  rawSchema,
+  schemas
+});
+//# sourceMappingURL=SandboxConfig.js.map