@taqueria/protocol 0.27.2-alpha → 0.27.3-rc

package/out/types/RequestArgs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RequestArgs.d.ts","sourceRoot":"","sources":["RequestArgs.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"RequestArgs.d.ts","sourceRoot":"","sources":["RequestArgs.ts"],"names":[],"mappings":"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"}

package/out/types/RequestArgs.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.requestArgsSchema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=RequestArgs.js.map

package/out/types/RuntimeDependency.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.runtimeDependencySchema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=RuntimeDependency.js.map

package/out/types/RuntimeDependencyReport.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.runtimeDependencyReportSchema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=RuntimeDependencyReport.js.map

package/out/types/SHA256.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.sha256Schema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=SHA256.js.map

package/out/types/SandboxAccountConfig.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.sandboxAccountConfigSchema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=SandboxAccountConfig.js.map

package/out/types/SandboxAccounts.d.js

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// out/types/SandboxAccounts.d.ts
+var SandboxAccounts_d_exports = {};
+module.exports = __toCommonJS(SandboxAccounts_d_exports);
+//# sourceMappingURL=SandboxAccounts.d.js.map

package/out/types/SandboxAccounts.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["SandboxAccounts.ts"],"sourcesContent":["// Generated file: Do not edit \n// generated from @taqueria-protocol-types\n    \nimport { TaqError, toFutureParseErr, toFutureParseUnknownErr, toParseErr, toParseUnknownErr } from '@taqueria/protocol/TaqError';\nimport { FutureInstance, resolve, reject } from 'fluture';\nimport { ZodError } from 'zod';\nimport { SandboxAccounts } from '@taqueria/protocol/types';\nimport { SandboxAccounts as SandboxAccountsStrict } from '@taqueria/protocol/out/types-strict';\nimport { sandboxAccountsSchema } from '@taqueria/protocol/out/types-zod';\n\nexport type { SandboxAccountsStrict as SandboxAccounts };\n\nexport const from = (input: unknown): SandboxAccountsStrict => {\n\ttry {\n\t\treturn sandboxAccountsSchema.parse(input) as SandboxAccountsStrict;\n\t}\n\tcatch (previous: unknown) {\n\t\tif (previous instanceof ZodError) {\n\t\t\tconst msgs: string[] = previous.errors.reduce(\n\t\t\t\t(retval, issue) => {\n\t\t\t\t\tconst path = issue.path.join(' → ');\n\t\t\t\t\tconst msg = path + ': ' + issue.message;\n\t\t\t\t\treturn [...retval, msg];\n\t\t\t\t},\n\t\t\t\t[\"SandboxAccounts is invalid:\"],\n\t\t\t);\n\t\t\tconst validationErr = msgs.join('\\n') + '\\n';\n\t\t\tthrow toParseErr(previous, validationErr);\n\t\t}\n\t\tthrow toParseUnknownErr(previous, \"There was a problem trying to parse a SandboxAccounts.\")\n\t}\n    \n};\n\nexport const create = (input: SandboxAccounts): SandboxAccountsStrict => from(input);\n\nexport const of = (input: unknown): FutureInstance<TaqError, SandboxAccountsStrict> => {\n\ttry {\n\t\treturn resolve(from(input))\n\t}\n\tcatch (err){\n\t\treturn reject(err) as FutureInstance<TaqError, never>\n\t}\n};\n\nexport const make = (input: Omit<SandboxAccountsStrict, '__type'>): FutureInstance<TaqError, SandboxAccountsStrict> => of(input);\n\n// TEMP: for interoperation with old protocol types during transition\nexport const schemas = {\n\trawSchema: sandboxAccountsSchema,\n\tschema: sandboxAccountsSchema.transform(val => val as SandboxAccountsStrict),\n};\nexport const rawSchema = schemas.rawSchema;\nexport const internalSchema = sandboxAccountsSchema;\n\nexport type t = SandboxAccountsStrict;\n        "],"mappings":";;;;;;;;;;;;;;;;AAGA;;","names":[]}

package/out/types/SandboxAccounts.d.ts

@@ -0,0 +1,43 @@
+import { TaqError } from '@taqueria/protocol/TaqError';
+import { FutureInstance } from 'fluture';
+import { SandboxAccounts } from '@taqueria/protocol/types';
+import { SandboxAccounts as SandboxAccountsStrict } from '@taqueria/protocol/out/types-strict';
+export type { SandboxAccountsStrict as SandboxAccounts };
+export declare const from: (input: unknown) => SandboxAccountsStrict;
+export declare const create: (input: SandboxAccounts) => SandboxAccountsStrict;
+export declare const of: (input: unknown) => FutureInstance<TaqError, SandboxAccountsStrict>;
+export declare const make: (input: Omit<SandboxAccountsStrict, '__type'>) => FutureInstance<TaqError, SandboxAccountsStrict>;
+export declare const schemas: {
+    rawSchema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        type: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type?: string | undefined;
+    }, {
+        type?: string | undefined;
+    }>>;
+    schema: import("zod").ZodEffects<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        type: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type?: string | undefined;
+    }, {
+        type?: string | undefined;
+    }>>, SandboxAccountsStrict, Record<string, {
+        type?: string | undefined;
+    }>>;
+};
+export declare const rawSchema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+    type: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    type?: string | undefined;
+}, {
+    type?: string | undefined;
+}>>;
+export declare const internalSchema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+    type: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    type?: string | undefined;
+}, {
+    type?: string | undefined;
+}>>;
+export type t = SandboxAccountsStrict;
+//# sourceMappingURL=SandboxAccounts.d.ts.map

package/out/types/SandboxAccounts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxAccounts.d.ts","sourceRoot":"","sources":["SandboxAccounts.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAA4E,MAAM,6BAA6B,CAAC;AACjI,OAAO,EAAE,cAAc,EAAmB,MAAM,SAAS,CAAC;AAE1D,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,eAAe,IAAI,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAG/F,YAAY,EAAE,qBAAqB,IAAI,eAAe,EAAE,CAAC;AAEzD,eAAO,MAAM,IAAI,UAAW,OAAO,KAAG,qBAoBrC,CAAC;AAEF,eAAO,MAAM,MAAM,UAAW,eAAe,KAAG,qBAAoC,CAAC;AAErF,eAAO,MAAM,EAAE,UAAW,OAAO,KAAG,eAAe,QAAQ,EAAE,qBAAqB,CAOjF,CAAC;AAEF,eAAO,MAAM,IAAI,UAAW,KAAK,qBAAqB,EAAE,QAAQ,CAAC,KAAG,eAAe,QAAQ,EAAE,qBAAqB,CAAc,CAAC;AAGjI,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;CAGnB,CAAC;AACF,eAAO,MAAM,SAAS;;;;;;GAAoB,CAAC;AAC3C,eAAO,MAAM,cAAc;;;;;;GAAwB,CAAC;AAEpD,MAAM,MAAM,CAAC,GAAG,qBAAqB,CAAC"}

package/out/types/SandboxAccounts.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// out/types/SandboxAccounts.ts
+var SandboxAccounts_exports = {};
+__export(SandboxAccounts_exports, {
+  create: () => create,
+  from: () => from,
+  internalSchema: () => internalSchema,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema,
+  schemas: () => schemas
+});
+module.exports = __toCommonJS(SandboxAccounts_exports);
+var import_TaqError = require("@taqueria/protocol/TaqError");
+var import_fluture = require("fluture");
+var import_zod = require("zod");
+var import_types_zod = require("@taqueria/protocol/out/types-zod");
+var from = (input) => {
+  try {
+    return import_types_zod.sandboxAccountsSchema.parse(input);
+  } catch (previous) {
+    if (previous instanceof import_zod.ZodError) {
+      const msgs = previous.errors.reduce(
+        (retval, issue) => {
+          const path = issue.path.join(" \u2192 ");
+          const msg = path + ": " + issue.message;
+          return [...retval, msg];
+        },
+        ["SandboxAccounts is invalid:"]
+      );
+      const validationErr = msgs.join("\n") + "\n";
+      throw (0, import_TaqError.toParseErr)(previous, validationErr);
+    }
+    throw (0, import_TaqError.toParseUnknownErr)(previous, "There was a problem trying to parse a SandboxAccounts.");
+  }
+};
+var create = (input) => from(input);
+var of = (input) => {
+  try {
+    return (0, import_fluture.resolve)(from(input));
+  } catch (err) {
+    return (0, import_fluture.reject)(err);
+  }
+};
+var make = (input) => of(input);
+var schemas = {
+  rawSchema: import_types_zod.sandboxAccountsSchema,
+  schema: import_types_zod.sandboxAccountsSchema.transform((val) => val)
+};
+var rawSchema = schemas.rawSchema;
+var internalSchema = import_types_zod.sandboxAccountsSchema;
+//# sourceMappingURL=SandboxAccounts.js.map

package/out/types/SandboxAccounts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["SandboxAccounts.ts"],"sourcesContent":["// Generated file: Do not edit \n// generated from @taqueria-protocol-types\n    \nimport { TaqError, toFutureParseErr, toFutureParseUnknownErr, toParseErr, toParseUnknownErr } from '@taqueria/protocol/TaqError';\nimport { FutureInstance, resolve, reject } from 'fluture';\nimport { ZodError } from 'zod';\nimport { SandboxAccounts } from '@taqueria/protocol/types';\nimport { SandboxAccounts as SandboxAccountsStrict } from '@taqueria/protocol/out/types-strict';\nimport { sandboxAccountsSchema } from '@taqueria/protocol/out/types-zod';\n\nexport type { SandboxAccountsStrict as SandboxAccounts };\n\nexport const from = (input: unknown): SandboxAccountsStrict => {\n\ttry {\n\t\treturn sandboxAccountsSchema.parse(input) as SandboxAccountsStrict;\n\t}\n\tcatch (previous: unknown) {\n\t\tif (previous instanceof ZodError) {\n\t\t\tconst msgs: string[] = previous.errors.reduce(\n\t\t\t\t(retval, issue) => {\n\t\t\t\t\tconst path = issue.path.join(' → ');\n\t\t\t\t\tconst msg = path + ': ' + issue.message;\n\t\t\t\t\treturn [...retval, msg];\n\t\t\t\t},\n\t\t\t\t[\"SandboxAccounts is invalid:\"],\n\t\t\t);\n\t\t\tconst validationErr = msgs.join('\\n') + '\\n';\n\t\t\tthrow toParseErr(previous, validationErr);\n\t\t}\n\t\tthrow toParseUnknownErr(previous, \"There was a problem trying to parse a SandboxAccounts.\")\n\t}\n    \n};\n\nexport const create = (input: SandboxAccounts): SandboxAccountsStrict => from(input);\n\nexport const of = (input: unknown): FutureInstance<TaqError, SandboxAccountsStrict> => {\n\ttry {\n\t\treturn resolve(from(input))\n\t}\n\tcatch (err){\n\t\treturn reject(err) as FutureInstance<TaqError, never>\n\t}\n};\n\nexport const make = (input: Omit<SandboxAccountsStrict, '__type'>): FutureInstance<TaqError, SandboxAccountsStrict> => of(input);\n\n// TEMP: for interoperation with old protocol types during transition\nexport const schemas = {\n\trawSchema: sandboxAccountsSchema,\n\tschema: sandboxAccountsSchema.transform(val => val as SandboxAccountsStrict),\n};\nexport const rawSchema = schemas.rawSchema;\nexport const internalSchema = sandboxAccountsSchema;\n\nexport type t = SandboxAccountsStrict;\n        "],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,sBAAmG;AACnG,qBAAgD;AAChD,iBAAyB;AAGzB,uBAAsC;AAI/B,IAAM,OAAO,CAAC,UAA0C;AAC9D,MAAI;AACH,WAAO,uCAAsB,MAAM,KAAK;AAAA,EACzC,SACO,UAAP;AACC,QAAI,oBAAoB,qBAAU;AACjC,YAAM,OAAiB,SAAS,OAAO;AAAA,QACtC,CAAC,QAAQ,UAAU;AAClB,gBAAM,OAAO,MAAM,KAAK,KAAK,UAAK;AAClC,gBAAM,MAAM,OAAO,OAAO,MAAM;AAChC,iBAAO,CAAC,GAAG,QAAQ,GAAG;AAAA,QACvB;AAAA,QACA,CAAC,6BAA6B;AAAA,MAC/B;AACA,YAAM,gBAAgB,KAAK,KAAK,IAAI,IAAI;AACxC,gBAAM,4BAAW,UAAU,aAAa;AAAA,IACzC;AACA,cAAM,mCAAkB,UAAU,wDAAwD;AAAA,EAC3F;AAED;AAEO,IAAM,SAAS,CAAC,UAAkD,KAAK,KAAK;AAE5E,IAAM,KAAK,CAAC,UAAoE;AACtF,MAAI;AACH,eAAO,wBAAQ,KAAK,KAAK,CAAC;AAAA,EAC3B,SACO,KAAP;AACC,eAAO,uBAAO,GAAG;AAAA,EAClB;AACD;AAEO,IAAM,OAAO,CAAC,UAAkG,GAAG,KAAK;AAGxH,IAAM,UAAU;AAAA,EACtB,WAAW;AAAA,EACX,QAAQ,uCAAsB,UAAU,SAAO,GAA4B;AAC5E;AACO,IAAM,YAAY,QAAQ;AAC1B,IAAM,iBAAiB;","names":[]}

package/out/types/SandboxConfig.d.ts

@@ -11,8 +11,7 @@ export declare const schemas: {
     rawSchema: import("zod").ZodObject<{
         label: import("zod").ZodString;
         rpcUrl: import("zod").ZodString;
-        protocol: import("zod").ZodString;
-        attributes: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>;
+        protocol: import("zod").ZodOptional<import("zod").ZodString>;
         plugin: import("zod").ZodOptional<import("zod").ZodString>;
         accounts: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
             encryptedKey: import("zod").ZodString;
@@ -40,6 +39,7 @@ export declare const schemas: {
             postgresqlPort?: number | undefined;
             apiPort?: number | undefined;
         }>>;
+        annotations: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
     }, "strip", import("zod").ZodTypeAny, {
         plugin?: string | undefined;
         accounts?: Record<string, string | {
@@ -47,15 +47,15 @@ export declare const schemas: {
             encryptedKey: string;
             secretKey: string;
         }> | undefined;
-        attributes?: string | number | boolean | undefined;
+        protocol?: string | undefined;
         tzkt?: {
             disableAutostartWithSandbox?: boolean | undefined;
             postgresqlPort?: number | undefined;
             apiPort?: number | undefined;
         } | undefined;
+        annotations?: Record<string, unknown> | undefined;
         label: string;
         rpcUrl: string;
-        protocol: string;
     }, {
         plugin?: string | undefined;
         accounts?: Record<string, string | {
@@ -63,21 +63,20 @@ export declare const schemas: {
             encryptedKey: string;
             secretKey: string;
         }> | undefined;
-        attributes?: string | number | boolean | undefined;
+        protocol?: string | undefined;
         tzkt?: {
             disableAutostartWithSandbox?: boolean | undefined;
             postgresqlPort?: number | undefined;
             apiPort?: number | undefined;
         } | undefined;
+        annotations?: Record<string, unknown> | undefined;
         label: string;
         rpcUrl: string;
-        protocol: string;
     }>;
     schema: import("zod").ZodEffects<import("zod").ZodObject<{
         label: import("zod").ZodString;
         rpcUrl: import("zod").ZodString;
-        protocol: import("zod").ZodString;
-        attributes: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>;
+        protocol: import("zod").ZodOptional<import("zod").ZodString>;
         plugin: import("zod").ZodOptional<import("zod").ZodString>;
         accounts: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
             encryptedKey: import("zod").ZodString;
@@ -105,6 +104,7 @@ export declare const schemas: {
             postgresqlPort?: number | undefined;
             apiPort?: number | undefined;
         }>>;
+        annotations: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
     }, "strip", import("zod").ZodTypeAny, {
         plugin?: string | undefined;
         accounts?: Record<string, string | {
@@ -112,15 +112,15 @@ export declare const schemas: {
             encryptedKey: string;
             secretKey: string;
         }> | undefined;
-        attributes?: string | number | boolean | undefined;
+        protocol?: string | undefined;
         tzkt?: {
             disableAutostartWithSandbox?: boolean | undefined;
             postgresqlPort?: number | undefined;
             apiPort?: number | undefined;
         } | undefined;
+        annotations?: Record<string, unknown> | undefined;
         label: string;
         rpcUrl: string;
-        protocol: string;
     }, {
         plugin?: string | undefined;
         accounts?: Record<string, string | {
@@ -128,15 +128,15 @@ export declare const schemas: {
             encryptedKey: string;
             secretKey: string;
         }> | undefined;
-        attributes?: string | number | boolean | undefined;
+        protocol?: string | undefined;
         tzkt?: {
             disableAutostartWithSandbox?: boolean | undefined;
             postgresqlPort?: number | undefined;
             apiPort?: number | undefined;
         } | undefined;
+        annotations?: Record<string, unknown> | undefined;
         label: string;
         rpcUrl: string;
-        protocol: string;
     }>, SandboxConfigStrict, {
         plugin?: string | undefined;
         accounts?: Record<string, string | {
@@ -144,22 +144,21 @@ export declare const schemas: {
             encryptedKey: string;
             secretKey: string;
         }> | undefined;
-        attributes?: string | number | boolean | undefined;
+        protocol?: string | undefined;
         tzkt?: {
             disableAutostartWithSandbox?: boolean | undefined;
             postgresqlPort?: number | undefined;
             apiPort?: number | undefined;
         } | undefined;
+        annotations?: Record<string, unknown> | undefined;
         label: string;
         rpcUrl: string;
-        protocol: string;
     }>;
 };
 export declare const rawSchema: import("zod").ZodObject<{
     label: import("zod").ZodString;
     rpcUrl: import("zod").ZodString;
-    protocol: import("zod").ZodString;
-    attributes: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>;
+    protocol: import("zod").ZodOptional<import("zod").ZodString>;
     plugin: import("zod").ZodOptional<import("zod").ZodString>;
     accounts: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
         encryptedKey: import("zod").ZodString;
@@ -187,6 +186,7 @@ export declare const rawSchema: import("zod").ZodObject<{
         postgresqlPort?: number | undefined;
         apiPort?: number | undefined;
     }>>;
+    annotations: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
 }, "strip", import("zod").ZodTypeAny, {
     plugin?: string | undefined;
     accounts?: Record<string, string | {
@@ -194,15 +194,15 @@ export declare const rawSchema: import("zod").ZodObject<{
         encryptedKey: string;
         secretKey: string;
     }> | undefined;
-    attributes?: string | number | boolean | undefined;
+    protocol?: string | undefined;
     tzkt?: {
         disableAutostartWithSandbox?: boolean | undefined;
         postgresqlPort?: number | undefined;
         apiPort?: number | undefined;
     } | undefined;
+    annotations?: Record<string, unknown> | undefined;
     label: string;
     rpcUrl: string;
-    protocol: string;
 }, {
     plugin?: string | undefined;
     accounts?: Record<string, string | {
@@ -210,21 +210,20 @@ export declare const rawSchema: import("zod").ZodObject<{
         encryptedKey: string;
         secretKey: string;
     }> | undefined;
-    attributes?: string | number | boolean | undefined;
+    protocol?: string | undefined;
     tzkt?: {
         disableAutostartWithSandbox?: boolean | undefined;
         postgresqlPort?: number | undefined;
         apiPort?: number | undefined;
     } | undefined;
+    annotations?: Record<string, unknown> | undefined;
     label: string;
     rpcUrl: string;
-    protocol: string;
 }>;
 export declare const internalSchema: import("zod").ZodObject<{
     label: import("zod").ZodString;
     rpcUrl: import("zod").ZodString;
-    protocol: import("zod").ZodString;
-    attributes: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>;
+    protocol: import("zod").ZodOptional<import("zod").ZodString>;
     plugin: import("zod").ZodOptional<import("zod").ZodString>;
     accounts: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodObject<{
         encryptedKey: import("zod").ZodString;
@@ -252,6 +251,7 @@ export declare const internalSchema: import("zod").ZodObject<{
         postgresqlPort?: number | undefined;
         apiPort?: number | undefined;
     }>>;
+    annotations: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
 }, "strip", import("zod").ZodTypeAny, {
     plugin?: string | undefined;
     accounts?: Record<string, string | {
@@ -259,15 +259,15 @@ export declare const internalSchema: import("zod").ZodObject<{
         encryptedKey: string;
         secretKey: string;
     }> | undefined;
-    attributes?: string | number | boolean | undefined;
+    protocol?: string | undefined;
     tzkt?: {
         disableAutostartWithSandbox?: boolean | undefined;
         postgresqlPort?: number | undefined;
         apiPort?: number | undefined;
     } | undefined;
+    annotations?: Record<string, unknown> | undefined;
     label: string;
     rpcUrl: string;
-    protocol: string;
 }, {
     plugin?: string | undefined;
     accounts?: Record<string, string | {
@@ -275,15 +275,15 @@ export declare const internalSchema: import("zod").ZodObject<{
         encryptedKey: string;
         secretKey: string;
     }> | undefined;
-    attributes?: string | number | boolean | undefined;
+    protocol?: string | undefined;
     tzkt?: {
         disableAutostartWithSandbox?: boolean | undefined;
         postgresqlPort?: number | undefined;
         apiPort?: number | undefined;
     } | undefined;
+    annotations?: Record<string, unknown> | undefined;
     label: string;
     rpcUrl: string;
-    protocol: string;
 }>;
 export type t = SandboxConfigStrict;
 //# sourceMappingURL=SandboxConfig.d.ts.map

package/out/types/SandboxConfig.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.sandboxConfigSchema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=SandboxConfig.js.map

package/out/types/SanitizedAbsPath.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.sanitizedAbsPathSchema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=SanitizedAbsPath.js.map

package/out/types/SanitizedArgs.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.sanitizedArgsSchema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=SanitizedArgs.js.map

package/out/types/SanitizedPath.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.sanitizedPathSchema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=SanitizedPath.js.map

package/out/types/ScaffoldConfig.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.scaffoldConfigSchema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=ScaffoldConfig.js.map

package/out/types/Settings.d.ts

@@ -9,35 +9,35 @@ export declare const of: (input: unknown) => FutureInstance<TaqError, SettingsSt
 export declare const make: (input: Omit<SettingsStrict, '__type'>) => FutureInstance<TaqError, SettingsStrict>;
 export declare const schemas: {
     rawSchema: import("zod").ZodObject<{
-        consent: import("zod").ZodUnion<[import("zod").ZodLiteral<"opt_in">, import("zod").ZodLiteral<"opt_out">]>;
+        consent: import("zod").ZodUnion<[import("zod").ZodLiteral<"opt_in">, import("zod").ZodLiteral<"opt_out">, import("zod").ZodLiteral<"unspecified">]>;
     }, "strip", import("zod").ZodTypeAny, {
-        consent: "opt_in" | "opt_out";
+        consent: "opt_in" | "opt_out" | "unspecified";
     }, {
-        consent: "opt_in" | "opt_out";
+        consent: "opt_in" | "opt_out" | "unspecified";
     }>;
     schema: import("zod").ZodEffects<import("zod").ZodObject<{
-        consent: import("zod").ZodUnion<[import("zod").ZodLiteral<"opt_in">, import("zod").ZodLiteral<"opt_out">]>;
+        consent: import("zod").ZodUnion<[import("zod").ZodLiteral<"opt_in">, import("zod").ZodLiteral<"opt_out">, import("zod").ZodLiteral<"unspecified">]>;
     }, "strip", import("zod").ZodTypeAny, {
-        consent: "opt_in" | "opt_out";
+        consent: "opt_in" | "opt_out" | "unspecified";
     }, {
-        consent: "opt_in" | "opt_out";
+        consent: "opt_in" | "opt_out" | "unspecified";
     }>, SettingsStrict, {
-        consent: "opt_in" | "opt_out";
+        consent: "opt_in" | "opt_out" | "unspecified";
     }>;
 };
 export declare const rawSchema: import("zod").ZodObject<{
-    consent: import("zod").ZodUnion<[import("zod").ZodLiteral<"opt_in">, import("zod").ZodLiteral<"opt_out">]>;
+    consent: import("zod").ZodUnion<[import("zod").ZodLiteral<"opt_in">, import("zod").ZodLiteral<"opt_out">, import("zod").ZodLiteral<"unspecified">]>;
 }, "strip", import("zod").ZodTypeAny, {
-    consent: "opt_in" | "opt_out";
+    consent: "opt_in" | "opt_out" | "unspecified";
 }, {
-    consent: "opt_in" | "opt_out";
+    consent: "opt_in" | "opt_out" | "unspecified";
 }>;
 export declare const internalSchema: import("zod").ZodObject<{
-    consent: import("zod").ZodUnion<[import("zod").ZodLiteral<"opt_in">, import("zod").ZodLiteral<"opt_out">]>;
+    consent: import("zod").ZodUnion<[import("zod").ZodLiteral<"opt_in">, import("zod").ZodLiteral<"opt_out">, import("zod").ZodLiteral<"unspecified">]>;
 }, "strip", import("zod").ZodTypeAny, {
-    consent: "opt_in" | "opt_out";
+    consent: "opt_in" | "opt_out" | "unspecified";
 }, {
-    consent: "opt_in" | "opt_out";
+    consent: "opt_in" | "opt_out" | "unspecified";
 }>;
 export type t = SettingsStrict;
 //# sourceMappingURL=Settings.d.ts.map

package/out/types/Settings.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.settingsSchema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=Settings.js.map

package/out/types/SingleChar.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.singleCharSchema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=SingleChar.js.map

package/out/types/Task.js

@@ -67,14 +67,4 @@ var schemas = {
 };
 var rawSchema = schemas.rawSchema;
 var internalSchema = import_types_zod.taskSchema;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  from,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas
-});
 //# sourceMappingURL=Task.js.map