@taqueria/protocol 0.24.2 → 0.25.3-alpha

package/LoadedConfig.d.ts.map

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

package/LoadedConfig.js

@@ -1,14 +1,8 @@
 "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))
@@ -17,64 +11,11 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // LoadedConfig.ts
 var LoadedConfig_exports = {};
-__export(LoadedConfig_exports, {
-  create: () => create,
-  factory: () => factory,
-  generatedSchemas: () => generatedSchemas,
-  internalSchema: () => internalSchema2,
-  make: () => make2,
-  of: () => of,
-  rawSchema: () => rawSchema4,
-  schemas: () => schemas3,
-  toConfig: () => toConfig
-});
 module.exports = __toCommonJS(LoadedConfig_exports);
-var import_Base = __toESM(require("@taqueria/protocol/Base"));
-var Config = __toESM(require("@taqueria/protocol/Config"));
-var SanitizedAbsPath = __toESM(require("@taqueria/protocol/SanitizedAbsPath"));
-var SHA256 = __toESM(require("@taqueria/protocol/SHA256"));
-var rawSchema4 = Config.rawSchema.omit({ plugins: true }).extend({
-  plugins: Config.pluginsRawSchema,
-  projectDir: SanitizedAbsPath.rawSchema.describe("loadedConfig.projectDir"),
-  configFile: SanitizedAbsPath.rawSchema.describe("loadedConfig.configFile"),
-  hash: SHA256.rawSchema.describe("loadedConfig.hash")
-}).describe("LoadedConfig");
-var internalSchema2 = Config.internalSchema.omit({ plugins: true }).extend({
-  plugins: Config.pluginsInternalSchema,
-  projectDir: SanitizedAbsPath.schemas.schema.describe("loadedConfig.projectDir"),
-  configFile: SanitizedAbsPath.schemas.schema.describe("loadedConfig.configFile"),
-  hash: SHA256.schemas.schema.describe("loadedConfig.hash")
-}).describe("LoadedConfig");
-var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
-  rawSchema: rawSchema4,
-  internalSchema: internalSchema2,
-  parseErrMsg: (value) => `The following configuration is invalid: ${value}`,
-  unknownErrMsg: "Something went wrong trying to parse the configuration to load"
-});
-var { create, of, make: make2 } = factory;
-var schemas3 = {
-  ...generatedSchemas,
-  schema: generatedSchemas.schema.transform((val) => val)
-};
-var toConfig = (config) => Config.make(config);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  create,
-  factory,
-  generatedSchemas,
-  internalSchema,
-  make,
-  of,
-  rawSchema,
-  schemas,
-  toConfig
-});
+__reExport(LoadedConfig_exports, require("@taqueria/protocol/out/types/LoadedConfig"), module.exports);
 //# sourceMappingURL=LoadedConfig.js.map

package/LoadedConfig.js.map

@@ -1 +1 @@
-{"version":3,"sources":["LoadedConfig.ts"],"sourcesContent":["import createType, { Flatten } from '@taqueria/protocol/Base';\nimport * as Config from '@taqueria/protocol/Config';\nimport * as SanitizedAbsPath from '@taqueria/protocol/SanitizedAbsPath';\nimport * as SHA256 from '@taqueria/protocol/SHA256';\nimport { z } from 'zod';\n\nexport const rawSchema = Config.rawSchema\n\t.omit({ plugins: true })\n\t.extend({\n\t\tplugins: Config.pluginsRawSchema,\n\t\tprojectDir: SanitizedAbsPath.rawSchema.describe('loadedConfig.projectDir'),\n\t\tconfigFile: SanitizedAbsPath.rawSchema.describe('loadedConfig.configFile'),\n\t\thash: SHA256.rawSchema.describe('loadedConfig.hash'),\n\t})\n\t.describe('LoadedConfig');\n\nexport const internalSchema = Config.internalSchema\n\t.omit({ plugins: true })\n\t.extend({\n\t\tplugins: Config.pluginsInternalSchema,\n\t\tprojectDir: SanitizedAbsPath.schemas.schema.describe('loadedConfig.projectDir'),\n\t\tconfigFile: SanitizedAbsPath.schemas.schema.describe('loadedConfig.configFile'),\n\t\thash: SHA256.schemas.schema.describe('loadedConfig.hash'),\n\t})\n\t.describe('LoadedConfig');\n\ntype RawInput = z.infer<typeof rawSchema>;\ntype Input = Flatten<z.infer<typeof internalSchema>>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: (value: unknown) => `The following configuration is invalid: ${value}`,\n\tunknownErrMsg: 'Something went wrong trying to parse the configuration to load',\n});\n\nexport type LoadedConfig = z.infer<typeof generatedSchemas.schema>;\nexport type t = LoadedConfig;\nexport const { create, of, make } = factory;\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as LoadedConfig),\n};\n\nexport const toConfig = (config: LoadedConfig) => Config.make(config);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAAAA;AAAA,EAAA,YAAAC;AAAA,EAAA;AAAA,mBAAAC;AAAA,EAAA,eAAAC;AAAA,EAAA;AAAA;AAAA;AAAA,kBAAoC;AACpC,aAAwB;AACxB,uBAAkC;AAClC,aAAwB;AAGjB,IAAMD,aAAmB,iBAC9B,KAAK,EAAE,SAAS,KAAK,CAAC,EACtB,OAAO;AAAA,EACP,SAAgB;AAAA,EAChB,YAA6B,2BAAU,SAAS,yBAAyB;AAAA,EACzE,YAA6B,2BAAU,SAAS,yBAAyB;AAAA,EACzE,MAAa,iBAAU,SAAS,mBAAmB;AACpD,CAAC,EACA,SAAS,cAAc;AAElB,IAAMF,kBAAwB,sBACnC,KAAK,EAAE,SAAS,KAAK,CAAC,EACtB,OAAO;AAAA,EACP,SAAgB;AAAA,EAChB,YAA6B,yBAAQ,OAAO,SAAS,yBAAyB;AAAA,EAC9E,YAA6B,yBAAQ,OAAO,SAAS,yBAAyB;AAAA,EAC9E,MAAa,eAAQ,OAAO,SAAS,mBAAmB;AACzD,CAAC,EACA,SAAS,cAAc;AAKlB,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAI,SAA4B;AAAA,EACjF,WAAAF;AAAA,EACA,gBAAAF;AAAA,EACA,aAAa,CAAC,UAAmB,2CAA2C;AAAA,EAC5E,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,IAAI,MAAAC,MAAK,IAAI;AAC7B,IAAME,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAmB;AACrE;AAEO,IAAM,WAAW,CAAC,WAAgC,YAAK,MAAM;","names":["internalSchema","make","rawSchema","schemas","createType"]}
+{"version":3,"sources":["LoadedConfig.ts"],"sourcesContent":["export * from '@taqueria/protocol/out/types/LoadedConfig';\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,iCAAc,sDAAd;","names":[]}

package/LoadedConfig.mjs

@@ -1,41 +1,3 @@
 // LoadedConfig.ts
-import createType from "@taqueria/protocol/Base";
-import * as Config from "@taqueria/protocol/Config";
-import * as SanitizedAbsPath from "@taqueria/protocol/SanitizedAbsPath";
-import * as SHA256 from "@taqueria/protocol/SHA256";
-var rawSchema4 = Config.rawSchema.omit({ plugins: true }).extend({
-  plugins: Config.pluginsRawSchema,
-  projectDir: SanitizedAbsPath.rawSchema.describe("loadedConfig.projectDir"),
-  configFile: SanitizedAbsPath.rawSchema.describe("loadedConfig.configFile"),
-  hash: SHA256.rawSchema.describe("loadedConfig.hash")
-}).describe("LoadedConfig");
-var internalSchema2 = Config.internalSchema.omit({ plugins: true }).extend({
-  plugins: Config.pluginsInternalSchema,
-  projectDir: SanitizedAbsPath.schemas.schema.describe("loadedConfig.projectDir"),
-  configFile: SanitizedAbsPath.schemas.schema.describe("loadedConfig.configFile"),
-  hash: SHA256.schemas.schema.describe("loadedConfig.hash")
-}).describe("LoadedConfig");
-var { schemas: generatedSchemas, factory } = createType({
-  rawSchema: rawSchema4,
-  internalSchema: internalSchema2,
-  parseErrMsg: (value) => `The following configuration is invalid: ${value}`,
-  unknownErrMsg: "Something went wrong trying to parse the configuration to load"
-});
-var { create, of, make: make2 } = factory;
-var schemas3 = {
-  ...generatedSchemas,
-  schema: generatedSchemas.schema.transform((val) => val)
-};
-var toConfig = (config) => Config.make(config);
-export {
-  create,
-  factory,
-  generatedSchemas,
-  internalSchema2 as internalSchema,
-  make2 as make,
-  of,
-  rawSchema4 as rawSchema,
-  schemas3 as schemas,
-  toConfig
-};
+export * from "@taqueria/protocol/out/types/LoadedConfig";
 //# sourceMappingURL=LoadedConfig.mjs.map

package/LoadedConfig.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["LoadedConfig.ts"],"sourcesContent":["import createType, { Flatten } from '@taqueria/protocol/Base';\nimport * as Config from '@taqueria/protocol/Config';\nimport * as SanitizedAbsPath from '@taqueria/protocol/SanitizedAbsPath';\nimport * as SHA256 from '@taqueria/protocol/SHA256';\nimport { z } from 'zod';\n\nexport const rawSchema = Config.rawSchema\n\t.omit({ plugins: true })\n\t.extend({\n\t\tplugins: Config.pluginsRawSchema,\n\t\tprojectDir: SanitizedAbsPath.rawSchema.describe('loadedConfig.projectDir'),\n\t\tconfigFile: SanitizedAbsPath.rawSchema.describe('loadedConfig.configFile'),\n\t\thash: SHA256.rawSchema.describe('loadedConfig.hash'),\n\t})\n\t.describe('LoadedConfig');\n\nexport const internalSchema = Config.internalSchema\n\t.omit({ plugins: true })\n\t.extend({\n\t\tplugins: Config.pluginsInternalSchema,\n\t\tprojectDir: SanitizedAbsPath.schemas.schema.describe('loadedConfig.projectDir'),\n\t\tconfigFile: SanitizedAbsPath.schemas.schema.describe('loadedConfig.configFile'),\n\t\thash: SHA256.schemas.schema.describe('loadedConfig.hash'),\n\t})\n\t.describe('LoadedConfig');\n\ntype RawInput = z.infer<typeof rawSchema>;\ntype Input = Flatten<z.infer<typeof internalSchema>>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: (value: unknown) => `The following configuration is invalid: ${value}`,\n\tunknownErrMsg: 'Something went wrong trying to parse the configuration to load',\n});\n\nexport type LoadedConfig = z.infer<typeof generatedSchemas.schema>;\nexport type t = LoadedConfig;\nexport const { create, of, make } = factory;\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as LoadedConfig),\n};\n\nexport const toConfig = (config: LoadedConfig) => Config.make(config);\n"],"mappings":";AAAA,OAAO,gBAA6B;AACpC,YAAY,YAAY;AACxB,YAAY,sBAAsB;AAClC,YAAY,YAAY;AAGjB,IAAMA,aAAmB,iBAC9B,KAAK,EAAE,SAAS,KAAK,CAAC,EACtB,OAAO;AAAA,EACP,SAAgB;AAAA,EAChB,YAA6B,2BAAU,SAAS,yBAAyB;AAAA,EACzE,YAA6B,2BAAU,SAAS,yBAAyB;AAAA,EACzE,MAAa,iBAAU,SAAS,mBAAmB;AACpD,CAAC,EACA,SAAS,cAAc;AAElB,IAAMC,kBAAwB,sBACnC,KAAK,EAAE,SAAS,KAAK,CAAC,EACtB,OAAO;AAAA,EACP,SAAgB;AAAA,EAChB,YAA6B,yBAAQ,OAAO,SAAS,yBAAyB;AAAA,EAC9E,YAA6B,yBAAQ,OAAO,SAAS,yBAAyB;AAAA,EAC9E,MAAa,eAAQ,OAAO,SAAS,mBAAmB;AACzD,CAAC,EACA,SAAS,cAAc;AAKlB,IAAM,EAAE,SAAS,kBAAkB,QAAQ,IAAI,WAA4B;AAAA,EACjF,WAAAD;AAAA,EACA,gBAAAC;AAAA,EACA,aAAa,CAAC,UAAmB,2CAA2C;AAAA,EAC5E,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,IAAI,MAAAC,MAAK,IAAI;AAC7B,IAAMC,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAmB;AACrE;AAEO,IAAM,WAAW,CAAC,WAAgC,YAAK,MAAM;","names":["rawSchema","internalSchema","make","schemas"]}
+{"version":3,"sources":["LoadedConfig.ts"],"sourcesContent":["export * from '@taqueria/protocol/out/types/LoadedConfig';\n"],"mappings":";AAAA,cAAc;","names":[]}

package/MetadataConfig.d.ts

@@ -1,155 +1,2 @@
-import { z } from 'zod';
-export declare const rawSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    projectDescription: z.ZodOptional<z.ZodString>;
-    authors: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
-    license: z.ZodOptional<z.ZodString>;
-    homepage: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    name?: string | undefined;
-    projectDescription?: string | undefined;
-    authors?: string[] | undefined;
-    license?: string | undefined;
-    homepage?: string | undefined;
-}, {
-    name?: string | undefined;
-    projectDescription?: string | undefined;
-    authors?: string[] | undefined;
-    license?: string | undefined;
-    homepage?: string | undefined;
-}>;
-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>, {
-        name?: string | undefined;
-        projectDescription?: string | undefined;
-        authors?: string[] | undefined;
-        license?: string | undefined;
-        homepage?: string | undefined;
-    } & {
-        readonly __kind: any;
-    }, any>;
-}, factory: {
-    make: (input: {
-        name?: string | undefined;
-        projectDescription?: string | undefined;
-        authors?: string[] | undefined;
-        license?: string | undefined;
-        homepage?: string | undefined;
-    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
-        name?: string | undefined;
-        projectDescription?: string | undefined;
-        authors?: string[] | undefined;
-        license?: string | undefined;
-        homepage?: string | undefined;
-    } & {
-        readonly __kind: any;
-    }>;
-    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
-        name?: string | undefined;
-        projectDescription?: string | undefined;
-        authors?: string[] | undefined;
-        license?: string | undefined;
-        homepage?: string | undefined;
-    } & {
-        readonly __kind: any;
-    }>;
-    create: (input: {
-        name?: string | undefined;
-        projectDescription?: string | undefined;
-        authors?: string[] | undefined;
-        license?: string | undefined;
-        homepage?: string | undefined;
-    } | {
-        name?: string | undefined;
-        projectDescription?: string | undefined;
-        authors?: string[] | undefined;
-        license?: string | undefined;
-        homepage?: string | undefined;
-    }) => {
-        name?: string | undefined;
-        projectDescription?: string | undefined;
-        authors?: string[] | undefined;
-        license?: string | undefined;
-        homepage?: string | undefined;
-    } & {
-        readonly __kind: any;
-    };
-    from: (input: unknown) => {
-        name?: string | undefined;
-        projectDescription?: string | undefined;
-        authors?: string[] | undefined;
-        license?: string | undefined;
-        homepage?: string | undefined;
-    } & {
-        readonly __kind: any;
-    };
-};
-export type MetadataConfig = z.infer<typeof generatedSchemas.schema>;
-export type t = MetadataConfig;
-export declare const create: (input: {
-    name?: string | undefined;
-    projectDescription?: string | undefined;
-    authors?: string[] | undefined;
-    license?: string | undefined;
-    homepage?: string | undefined;
-} | {
-    name?: string | undefined;
-    projectDescription?: string | undefined;
-    authors?: string[] | undefined;
-    license?: string | undefined;
-    homepage?: string | undefined;
-}) => {
-    name?: string | undefined;
-    projectDescription?: string | undefined;
-    authors?: string[] | undefined;
-    license?: string | undefined;
-    homepage?: string | undefined;
-} & {
-    readonly __kind: any;
-}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
-    name?: string | undefined;
-    projectDescription?: string | undefined;
-    authors?: string[] | undefined;
-    license?: string | undefined;
-    homepage?: string | undefined;
-} & {
-    readonly __kind: any;
-}>, make: (input: {
-    name?: string | undefined;
-    projectDescription?: string | undefined;
-    authors?: string[] | undefined;
-    license?: string | undefined;
-    homepage?: string | undefined;
-}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
-    name?: string | undefined;
-    projectDescription?: string | undefined;
-    authors?: string[] | undefined;
-    license?: string | undefined;
-    homepage?: string | undefined;
-} & {
-    readonly __kind: any;
-}>;
-export declare const schemas: {
-    schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
-        name?: string | undefined;
-        projectDescription?: string | undefined;
-        authors?: string[] | undefined;
-        license?: string | undefined;
-        homepage?: string | undefined;
-    } & {
-        readonly __kind: any;
-    }, any>, {
-        name?: string | undefined;
-        projectDescription?: string | undefined;
-        authors?: string[] | undefined;
-        license?: string | undefined;
-        homepage?: string | undefined;
-    } & {
-        readonly __kind: any;
-    }, any>;
-    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
-    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
-};
+export * from '@taqueria/protocol/out/types/MetadataConfig';
 //# sourceMappingURL=MetadataConfig.d.ts.map

package/MetadataConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MetadataConfig.d.ts","sourceRoot":"","sources":["MetadataConfig.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;EAMpB,CAAC;AAaH,eAAO,MAAiB,gBAAgB;;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK/C,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AACrE,MAAM,MAAM,CAAC,GAAG,cAAc,CAAC;AAC/B,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;GAAE,EAAE;;;;;;;;IAAE,IAAI;;;;;;;;;;;;;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC"}
+{"version":3,"file":"MetadataConfig.d.ts","sourceRoot":"","sources":["MetadataConfig.ts"],"names":[],"mappings":"AAAA,cAAc,6CAA6C,CAAC"}

package/MetadataConfig.js

@@ -1,14 +1,8 @@
 "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))
@@ -17,59 +11,11 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // MetadataConfig.ts
 var MetadataConfig_exports = {};
-__export(MetadataConfig_exports, {
-  create: () => create,
-  factory: () => factory,
-  generatedSchemas: () => generatedSchemas,
-  make: () => make,
-  of: () => of,
-  rawSchema: () => rawSchema,
-  schemas: () => schemas
-});
 module.exports = __toCommonJS(MetadataConfig_exports);
-var import_Base = __toESM(require("@taqueria/protocol/Base"));
-var import_zod = require("zod");
-var rawSchema = import_zod.z.object({
-  name: import_zod.z.string({ description: "Project Name" }).optional(),
-  projectDescription: import_zod.z.string({ description: "Project Description" }).optional(),
-  authors: import_zod.z.array(import_zod.z.string({ description: "Project Author" })).default([]).describe("Project Authors").optional(),
-  license: import_zod.z.string({ description: "Project License" }).optional(),
-  homepage: import_zod.z.string({ description: "Project Web Url" }).optional()
-});
-var internalSchema = import_zod.z.object({
-  name: import_zod.z.string({ description: "Project Name" }).optional(),
-  projectDescription: import_zod.z.string({ description: "Project Description" }).optional(),
-  authors: import_zod.z.array(import_zod.z.string({ description: "Project Author" })).default([]).describe("Project Authors").optional(),
-  license: import_zod.z.string({ description: "Project License" }).optional(),
-  homepage: import_zod.z.string({ description: "Project Web Url" }).optional()
-}, { description: "Project Metadata" });
-var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
-  rawSchema,
-  internalSchema,
-  parseErrMsg: (value) => `${value} is not a valid metadata configuration `,
-  unknownErrMsg: "Something went wrong trying to parse the metadata configuration"
-});
-var { create, of, make } = factory;
-var schemas = {
-  ...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
-});
+__reExport(MetadataConfig_exports, require("@taqueria/protocol/out/types/MetadataConfig"), module.exports);
 //# sourceMappingURL=MetadataConfig.js.map

package/MetadataConfig.js.map

@@ -1 +1 @@
-{"version":3,"sources":["MetadataConfig.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nexport const rawSchema = z.object({\n\tname: z.string({ description: 'Project Name' }).optional(),\n\tprojectDescription: z.string({ description: 'Project Description' }).optional(),\n\tauthors: z.array(z.string({ description: 'Project Author' })).default([]).describe('Project Authors').optional(),\n\tlicense: z.string({ description: 'Project License' }).optional(),\n\thomepage: z.string({ description: 'Project Web Url' }).optional(),\n});\n\nconst internalSchema = z.object({\n\tname: z.string({ description: 'Project Name' }).optional(),\n\tprojectDescription: z.string({ description: 'Project Description' }).optional(),\n\tauthors: z.array(z.string({ description: 'Project Author' })).default([]).describe('Project Authors').optional(),\n\tlicense: z.string({ description: 'Project License' }).optional(),\n\thomepage: z.string({ description: 'Project Web Url' }).optional(),\n}, { description: 'Project Metadata' });\n\ntype RawInput = z.infer<typeof rawSchema>;\ntype Input = z.infer<typeof internalSchema>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: (value: unknown) => `${value} is not a valid metadata configuration `,\n\tunknownErrMsg: 'Something went wrong trying to parse the metadata configuration',\n});\n\nexport type MetadataConfig = z.infer<typeof generatedSchemas.schema>;\nexport type t = MetadataConfig;\nexport const { create, of, make } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as MetadataConfig),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAuB;AACvB,iBAAkB;AAEX,IAAM,YAAY,aAAE,OAAO;AAAA,EACjC,MAAM,aAAE,OAAO,EAAE,aAAa,eAAe,CAAC,EAAE,SAAS;AAAA,EACzD,oBAAoB,aAAE,OAAO,EAAE,aAAa,sBAAsB,CAAC,EAAE,SAAS;AAAA,EAC9E,SAAS,aAAE,MAAM,aAAE,OAAO,EAAE,aAAa,iBAAiB,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,EAAE,SAAS,iBAAiB,EAAE,SAAS;AAAA,EAC/G,SAAS,aAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,SAAS;AAAA,EAC/D,UAAU,aAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,SAAS;AACjE,CAAC;AAED,IAAM,iBAAiB,aAAE,OAAO;AAAA,EAC/B,MAAM,aAAE,OAAO,EAAE,aAAa,eAAe,CAAC,EAAE,SAAS;AAAA,EACzD,oBAAoB,aAAE,OAAO,EAAE,aAAa,sBAAsB,CAAC,EAAE,SAAS;AAAA,EAC9E,SAAS,aAAE,MAAM,aAAE,OAAO,EAAE,aAAa,iBAAiB,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,EAAE,SAAS,iBAAiB,EAAE,SAAS;AAAA,EAC/G,SAAS,aAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,SAAS;AAAA,EAC/D,UAAU,aAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,SAAS;AACjE,GAAG,EAAE,aAAa,mBAAmB,CAAC;AAK/B,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAA,SAA4B;AAAA,EACjF;AAAA,EACA;AAAA,EACA,aAAa,CAAC,UAAmB,GAAG;AAAA,EACpC,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAE7B,IAAM,UAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAqB;AACvE;","names":["createType"]}
+{"version":3,"sources":["MetadataConfig.ts"],"sourcesContent":["export * from '@taqueria/protocol/out/types/MetadataConfig';\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,mCAAc,wDAAd;","names":[]}

package/MetadataConfig.mjs

@@ -1,38 +1,3 @@
 // MetadataConfig.ts
-import createType from "@taqueria/protocol/Base";
-import { z } from "zod";
-var rawSchema = z.object({
-  name: z.string({ description: "Project Name" }).optional(),
-  projectDescription: z.string({ description: "Project Description" }).optional(),
-  authors: z.array(z.string({ description: "Project Author" })).default([]).describe("Project Authors").optional(),
-  license: z.string({ description: "Project License" }).optional(),
-  homepage: z.string({ description: "Project Web Url" }).optional()
-});
-var internalSchema = z.object({
-  name: z.string({ description: "Project Name" }).optional(),
-  projectDescription: z.string({ description: "Project Description" }).optional(),
-  authors: z.array(z.string({ description: "Project Author" })).default([]).describe("Project Authors").optional(),
-  license: z.string({ description: "Project License" }).optional(),
-  homepage: z.string({ description: "Project Web Url" }).optional()
-}, { description: "Project Metadata" });
-var { schemas: generatedSchemas, factory } = createType({
-  rawSchema,
-  internalSchema,
-  parseErrMsg: (value) => `${value} is not a valid metadata configuration `,
-  unknownErrMsg: "Something went wrong trying to parse the metadata configuration"
-});
-var { create, of, make } = factory;
-var schemas = {
-  ...generatedSchemas,
-  schema: generatedSchemas.schema.transform((val) => val)
-};
-export {
-  create,
-  factory,
-  generatedSchemas,
-  make,
-  of,
-  rawSchema,
-  schemas
-};
+export * from "@taqueria/protocol/out/types/MetadataConfig";
 //# sourceMappingURL=MetadataConfig.mjs.map

package/MetadataConfig.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["MetadataConfig.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nexport const rawSchema = z.object({\n\tname: z.string({ description: 'Project Name' }).optional(),\n\tprojectDescription: z.string({ description: 'Project Description' }).optional(),\n\tauthors: z.array(z.string({ description: 'Project Author' })).default([]).describe('Project Authors').optional(),\n\tlicense: z.string({ description: 'Project License' }).optional(),\n\thomepage: z.string({ description: 'Project Web Url' }).optional(),\n});\n\nconst internalSchema = z.object({\n\tname: z.string({ description: 'Project Name' }).optional(),\n\tprojectDescription: z.string({ description: 'Project Description' }).optional(),\n\tauthors: z.array(z.string({ description: 'Project Author' })).default([]).describe('Project Authors').optional(),\n\tlicense: z.string({ description: 'Project License' }).optional(),\n\thomepage: z.string({ description: 'Project Web Url' }).optional(),\n}, { description: 'Project Metadata' });\n\ntype RawInput = z.infer<typeof rawSchema>;\ntype Input = z.infer<typeof internalSchema>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({\n\trawSchema,\n\tinternalSchema,\n\tparseErrMsg: (value: unknown) => `${value} is not a valid metadata configuration `,\n\tunknownErrMsg: 'Something went wrong trying to parse the metadata configuration',\n});\n\nexport type MetadataConfig = z.infer<typeof generatedSchemas.schema>;\nexport type t = MetadataConfig;\nexport const { create, of, make } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as MetadataConfig),\n};\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,SAAS,SAAS;AAEX,IAAM,YAAY,EAAE,OAAO;AAAA,EACjC,MAAM,EAAE,OAAO,EAAE,aAAa,eAAe,CAAC,EAAE,SAAS;AAAA,EACzD,oBAAoB,EAAE,OAAO,EAAE,aAAa,sBAAsB,CAAC,EAAE,SAAS;AAAA,EAC9E,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,iBAAiB,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,EAAE,SAAS,iBAAiB,EAAE,SAAS;AAAA,EAC/G,SAAS,EAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,SAAS;AAAA,EAC/D,UAAU,EAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,SAAS;AACjE,CAAC;AAED,IAAM,iBAAiB,EAAE,OAAO;AAAA,EAC/B,MAAM,EAAE,OAAO,EAAE,aAAa,eAAe,CAAC,EAAE,SAAS;AAAA,EACzD,oBAAoB,EAAE,OAAO,EAAE,aAAa,sBAAsB,CAAC,EAAE,SAAS;AAAA,EAC9E,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,iBAAiB,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,EAAE,SAAS,iBAAiB,EAAE,SAAS;AAAA,EAC/G,SAAS,EAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,SAAS;AAAA,EAC/D,UAAU,EAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,SAAS;AACjE,GAAG,EAAE,aAAa,mBAAmB,CAAC;AAK/B,IAAM,EAAE,SAAS,kBAAkB,QAAQ,IAAI,WAA4B;AAAA,EACjF;AAAA,EACA;AAAA,EACA,aAAa,CAAC,UAAmB,GAAG;AAAA,EACpC,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAE7B,IAAM,UAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAqB;AACvE;","names":[]}
+{"version":3,"sources":["MetadataConfig.ts"],"sourcesContent":["export * from '@taqueria/protocol/out/types/MetadataConfig';\n"],"mappings":";AAAA,cAAc;","names":[]}

package/NetworkAccountConfig.d.ts

@@ -0,0 +1,2 @@
+export * from '@taqueria/protocol/out/types/NetworkAccountConfig';
+//# sourceMappingURL=NetworkAccountConfig.d.ts.map

package/NetworkAccountConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkAccountConfig.d.ts","sourceRoot":"","sources":["NetworkAccountConfig.ts"],"names":[],"mappings":"AAAA,cAAc,mDAAmD,CAAC"}

package/NetworkAccountConfig.js

@@ -0,0 +1,21 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// NetworkAccountConfig.ts
+var NetworkAccountConfig_exports = {};
+module.exports = __toCommonJS(NetworkAccountConfig_exports);
+__reExport(NetworkAccountConfig_exports, require("@taqueria/protocol/out/types/NetworkAccountConfig"), module.exports);
+//# sourceMappingURL=NetworkAccountConfig.js.map

package/NetworkAccountConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["NetworkAccountConfig.ts"],"sourcesContent":["export * from '@taqueria/protocol/out/types/NetworkAccountConfig';\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,yCAAc,8DAAd;","names":[]}

package/NetworkAccountConfig.mjs

@@ -0,0 +1,3 @@
+// NetworkAccountConfig.ts
+export * from "@taqueria/protocol/out/types/NetworkAccountConfig";
+//# sourceMappingURL=NetworkAccountConfig.mjs.map

package/NetworkAccountConfig.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["NetworkAccountConfig.ts"],"sourcesContent":["export * from '@taqueria/protocol/out/types/NetworkAccountConfig';\n"],"mappings":";AAAA,cAAc;","names":[]}