@taqueria/protocol 0.25.4-alpha → 0.25.11-rc

package/Template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Template.d.ts","sourceRoot":"","sources":["Template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAErF,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,cAAc,uCAAuC,CAAC;AAEtD,KAAK,eAAe,GACjB,cAAc,CAAC,CAAC,GAChB,CAAC,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,KACpB,kBAAkB,CAAC,CAAC,GACpB,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC,CAAC;AAEjB,KAAK,aAAa,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG;IAChD,OAAO,EAAE,eAAe,CAAC;CACzB,CAAC;AAEF,wBAAgB,MAAM,CAAC,IAAI,EAAE,aAAa,4DAEzC"}
+{"version":3,"file":"Template.d.ts","sourceRoot":"","sources":["Template.ts"],"names":[],"mappings":"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"}

package/Template.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,22 +17,101 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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);
 
 // Template.ts
 var Template_exports = {};
 __export(Template_exports, {
-  create: () => create
+  create: () => create,
+  factory: () => factory,
+  generatedSchemas: () => generatedSchemas,
+  internalSchema: () => internalSchema,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema5,
+  schemas: () => schemas8
 });
 module.exports = __toCommonJS(Template_exports);
-var import_Template = require("@taqueria/protocol/out/types/Template");
-__reExport(Template_exports, require("@taqueria/protocol/out/types/Template"), module.exports);
-function create(args) {
-  return (0, import_Template.create)(args);
-}
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var Command = __toESM(require("@taqueria/protocol/Command"));
+var Option = __toESM(require("@taqueria/protocol/Option"));
+var PluginJsonResponse = __toESM(require("@taqueria/protocol/PluginJsonResponse"));
+var PluginResponseEncoding = __toESM(require("@taqueria/protocol/PluginResponseEncoding"));
+var PositionalArg = __toESM(require("@taqueria/protocol/PositionalArg"));
+var RequestArgs = __toESM(require("@taqueria/protocol/RequestArgs"));
+var Verb = __toESM(require("@taqueria/protocol/Verb"));
+var import_zod = require("zod");
+var handlerSchema = import_zod.z.union([
+  import_zod.z.string().min(1),
+  import_zod.z.function().args(RequestArgs.schemas.schema).returns(import_zod.z.union([
+    import_zod.z.void(),
+    PluginJsonResponse.schemas.schema,
+    PluginJsonResponse.schemas.internalSchema,
+    import_zod.z.promise(
+      import_zod.z.union([
+        import_zod.z.promise(import_zod.z.void()),
+        import_zod.z.void(),
+        PluginJsonResponse.schemas.schema,
+        PluginJsonResponse.schemas.internalSchema
+      ])
+    )
+  ]))
+]);
+var rawSchema5 = import_zod.z.object({
+  template: Verb.rawSchema,
+  command: Command.rawSchema,
+  description: import_zod.z.string().min(4),
+  hidden: import_zod.z.preprocess(
+    (val) => val ?? false,
+    import_zod.z.boolean()
+  ).optional(),
+  options: import_zod.z.preprocess(
+    (val) => val ?? [],
+    import_zod.z.array(Option.rawSchema)
+  ).optional(),
+  positionals: import_zod.z.preprocess(
+    (val) => val ?? [],
+    import_zod.z.array(PositionalArg.rawSchema)
+  ).optional(),
+  handler: handlerSchema.describe("Template Handler"),
+  encoding: PluginResponseEncoding.schemas.schema.optional()
+});
+var internalSchema = rawSchema5.extend({
+  template: Verb.schemas.schema,
+  command: Command.schemas.schema,
+  options: import_zod.z.preprocess(
+    (val) => val ?? [],
+    import_zod.z.array(Option.schemas.schema)
+  ).optional(),
+  positionals: import_zod.z.preprocess(
+    (val) => val ?? [],
+    import_zod.z.array(PositionalArg.schemas.schema)
+  ).optional()
+});
+var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
+  rawSchema: rawSchema5,
+  internalSchema,
+  parseErrMsg: (value) => `The following template is invalid: ${value}`,
+  unknownErrMsg: "Something went wrong trying to parse the template"
+});
+var { create, make, of } = factory;
+var schemas8 = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  create
+  create,
+  factory,
+  generatedSchemas,
+  internalSchema,
+  make,
+  of,
+  rawSchema,
+  schemas
 });
 //# sourceMappingURL=Template.js.map

package/Template.js.map

@@ -1 +1 @@
-{"version":3,"sources":["Template.ts"],"sourcesContent":["import { NonEmptyString, PluginJsonResponse, RequestArgs } from '@taqueria/protocol';\nimport { create as createTemplate } from '@taqueria/protocol/out/types/Template';\nimport { Template } from '@taqueria/protocol/types';\nexport * from '@taqueria/protocol/out/types/Template';\n\ntype TemplateHandler =\n\t| NonEmptyString.t // TODO: should this be Verb?\n\t| ((args: RequestArgs.t) =>\n\t\t| PluginJsonResponse.t\n\t\t| Promise<PluginJsonResponse.t>)\n\t| Promise<void>;\n\ntype InputTemplate = Omit<Template, 'handler'> & {\n\thandler: TemplateHandler;\n};\n\nexport function create(args: InputTemplate) {\n\treturn createTemplate(args as Template);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,sBAAyC;AAEzC,6BAAc,kDAHd;AAgBO,SAAS,OAAO,MAAqB;AAC3C,aAAO,gBAAAA,QAAe,IAAgB;AACvC;","names":["createTemplate"]}
+{"version":3,"sources":["Template.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as Command from '@taqueria/protocol/Command';\nimport * as Option from '@taqueria/protocol/Option';\nimport * as PluginJsonResponse from '@taqueria/protocol/PluginJsonResponse';\nimport * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';\nimport * as PositionalArg from '@taqueria/protocol/PositionalArg';\nimport * as RequestArgs from '@taqueria/protocol/RequestArgs';\nimport * as Verb from '@taqueria/protocol/Verb';\nimport { z } from 'zod';\n\nconst handlerSchema = z.union([\n\tz.string().min(1),\n\tz.function().args(RequestArgs.schemas.schema).returns(z.union([\n\t\tz.void(),\n\t\tPluginJsonResponse.schemas.schema,\n\t\tPluginJsonResponse.schemas.internalSchema,\n\t\tz.promise(\n\t\t\tz.union([\n\t\t\t\tz.promise(z.void()),\n\t\t\t\tz.void(),\n\t\t\t\tPluginJsonResponse.schemas.schema,\n\t\t\t\tPluginJsonResponse.schemas.internalSchema,\n\t\t\t]),\n\t\t),\n\t])),\n]);\n\nexport const rawSchema = z.object({\n\ttemplate: Verb.rawSchema,\n\tcommand: Command.rawSchema,\n\tdescription: z.string().min(4),\n\thidden: z.preprocess(\n\t\tval => val ?? false,\n\t\tz.boolean(),\n\t).optional(),\n\toptions: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(Option.rawSchema),\n\t).optional(),\n\tpositionals: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(PositionalArg.rawSchema),\n\t).optional(),\n\thandler: handlerSchema.describe('Template Handler'),\n\tencoding: PluginResponseEncoding.schemas.schema.optional(),\n});\n\nexport const internalSchema = rawSchema.extend({\n\ttemplate: Verb.schemas.schema,\n\tcommand: Command.schemas.schema,\n\toptions: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(Option.schemas.schema),\n\t).optional(),\n\tpositionals: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(PositionalArg.schemas.schema),\n\t).optional(),\n});\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) => `The following template is invalid: ${value}`,\n\tunknownErrMsg: 'Something went wrong trying to parse the template',\n});\n\nexport type Template = z.infer<typeof generatedSchemas.schema>;\nexport type t = Template;\nexport const { create, make, of } = factory;\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as unknown as Template),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAAA;AAAA,EAAA,eAAAC;AAAA;AAAA;AAAA,kBAAuB;AACvB,cAAyB;AACzB,aAAwB;AACxB,yBAAoC;AACpC,6BAAwC;AACxC,oBAA+B;AAC/B,kBAA6B;AAC7B,WAAsB;AACtB,iBAAkB;AAElB,IAAM,gBAAgB,aAAE,MAAM;AAAA,EAC7B,aAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EAChB,aAAE,SAAS,EAAE,KAAiB,oBAAQ,MAAM,EAAE,QAAQ,aAAE,MAAM;AAAA,IAC7D,aAAE,KAAK;AAAA,IACY,2BAAQ;AAAA,IACR,2BAAQ;AAAA,IAC3B,aAAE;AAAA,MACD,aAAE,MAAM;AAAA,QACP,aAAE,QAAQ,aAAE,KAAK,CAAC;AAAA,QAClB,aAAE,KAAK;AAAA,QACY,2BAAQ;AAAA,QACR,2BAAQ;AAAA,MAC5B,CAAC;AAAA,IACF;AAAA,EACD,CAAC,CAAC;AACH,CAAC;AAEM,IAAMD,aAAY,aAAE,OAAO;AAAA,EACjC,UAAe;AAAA,EACf,SAAiB;AAAA,EACjB,aAAa,aAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EAC7B,QAAQ,aAAE;AAAA,IACT,SAAO,OAAO;AAAA,IACd,aAAE,QAAQ;AAAA,EACX,EAAE,SAAS;AAAA,EACX,SAAS,aAAE;AAAA,IACV,SAAO,OAAO,CAAC;AAAA,IACf,aAAE,MAAa,gBAAS;AAAA,EACzB,EAAE,SAAS;AAAA,EACX,aAAa,aAAE;AAAA,IACd,SAAO,OAAO,CAAC;AAAA,IACf,aAAE,MAAoB,uBAAS;AAAA,EAChC,EAAE,SAAS;AAAA,EACX,SAAS,cAAc,SAAS,kBAAkB;AAAA,EAClD,UAAiC,+BAAQ,OAAO,SAAS;AAC1D,CAAC;AAEM,IAAM,iBAAiBA,WAAU,OAAO;AAAA,EAC9C,UAAe,aAAQ;AAAA,EACvB,SAAiB,gBAAQ;AAAA,EACzB,SAAS,aAAE;AAAA,IACV,SAAO,OAAO,CAAC;AAAA,IACf,aAAE,MAAa,eAAQ,MAAM;AAAA,EAC9B,EAAE,SAAS;AAAA,EACX,aAAa,aAAE;AAAA,IACd,SAAO,OAAO,CAAC;AAAA,IACf,aAAE,MAAoB,sBAAQ,MAAM;AAAA,EACrC,EAAE,SAAS;AACZ,CAAC;AAKM,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAE,SAA4B;AAAA,EACjF,WAAAF;AAAA,EACA;AAAA,EACA,aAAa,CAAC,UAAmB,sCAAsC;AAAA,EACvE,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,MAAM,GAAG,IAAI;AAC7B,IAAMC,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAA0B;AAC5E;","names":["rawSchema","schemas","createType"]}

package/Template.mjs

@@ -1,10 +1,79 @@
 // Template.ts
-import { create as createTemplate } from "@taqueria/protocol/out/types/Template";
-export * from "@taqueria/protocol/out/types/Template";
-function create(args) {
-  return createTemplate(args);
-}
+import createType from "@taqueria/protocol/Base";
+import * as Command from "@taqueria/protocol/Command";
+import * as Option from "@taqueria/protocol/Option";
+import * as PluginJsonResponse from "@taqueria/protocol/PluginJsonResponse";
+import * as PluginResponseEncoding from "@taqueria/protocol/PluginResponseEncoding";
+import * as PositionalArg from "@taqueria/protocol/PositionalArg";
+import * as RequestArgs from "@taqueria/protocol/RequestArgs";
+import * as Verb from "@taqueria/protocol/Verb";
+import { z } from "zod";
+var handlerSchema = z.union([
+  z.string().min(1),
+  z.function().args(RequestArgs.schemas.schema).returns(z.union([
+    z.void(),
+    PluginJsonResponse.schemas.schema,
+    PluginJsonResponse.schemas.internalSchema,
+    z.promise(
+      z.union([
+        z.promise(z.void()),
+        z.void(),
+        PluginJsonResponse.schemas.schema,
+        PluginJsonResponse.schemas.internalSchema
+      ])
+    )
+  ]))
+]);
+var rawSchema5 = z.object({
+  template: Verb.rawSchema,
+  command: Command.rawSchema,
+  description: z.string().min(4),
+  hidden: z.preprocess(
+    (val) => val ?? false,
+    z.boolean()
+  ).optional(),
+  options: z.preprocess(
+    (val) => val ?? [],
+    z.array(Option.rawSchema)
+  ).optional(),
+  positionals: z.preprocess(
+    (val) => val ?? [],
+    z.array(PositionalArg.rawSchema)
+  ).optional(),
+  handler: handlerSchema.describe("Template Handler"),
+  encoding: PluginResponseEncoding.schemas.schema.optional()
+});
+var internalSchema = rawSchema5.extend({
+  template: Verb.schemas.schema,
+  command: Command.schemas.schema,
+  options: z.preprocess(
+    (val) => val ?? [],
+    z.array(Option.schemas.schema)
+  ).optional(),
+  positionals: z.preprocess(
+    (val) => val ?? [],
+    z.array(PositionalArg.schemas.schema)
+  ).optional()
+});
+var { schemas: generatedSchemas, factory } = createType({
+  rawSchema: rawSchema5,
+  internalSchema,
+  parseErrMsg: (value) => `The following template is invalid: ${value}`,
+  unknownErrMsg: "Something went wrong trying to parse the template"
+});
+var { create, make, of } = factory;
+var schemas8 = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
 export {
-  create
+  create,
+  factory,
+  generatedSchemas,
+  internalSchema,
+  make,
+  of,
+  rawSchema5 as rawSchema,
+  schemas8 as schemas
 };
 //# sourceMappingURL=Template.mjs.map

package/Template.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["Template.ts"],"sourcesContent":["import { NonEmptyString, PluginJsonResponse, RequestArgs } from '@taqueria/protocol';\nimport { create as createTemplate } from '@taqueria/protocol/out/types/Template';\nimport { Template } from '@taqueria/protocol/types';\nexport * from '@taqueria/protocol/out/types/Template';\n\ntype TemplateHandler =\n\t| NonEmptyString.t // TODO: should this be Verb?\n\t| ((args: RequestArgs.t) =>\n\t\t| PluginJsonResponse.t\n\t\t| Promise<PluginJsonResponse.t>)\n\t| Promise<void>;\n\ntype InputTemplate = Omit<Template, 'handler'> & {\n\thandler: TemplateHandler;\n};\n\nexport function create(args: InputTemplate) {\n\treturn createTemplate(args as Template);\n}\n"],"mappings":";AACA,SAAS,UAAU,sBAAsB;AAEzC,cAAc;AAaP,SAAS,OAAO,MAAqB;AAC3C,SAAO,eAAe,IAAgB;AACvC;","names":[]}
+{"version":3,"sources":["Template.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport * as Command from '@taqueria/protocol/Command';\nimport * as Option from '@taqueria/protocol/Option';\nimport * as PluginJsonResponse from '@taqueria/protocol/PluginJsonResponse';\nimport * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';\nimport * as PositionalArg from '@taqueria/protocol/PositionalArg';\nimport * as RequestArgs from '@taqueria/protocol/RequestArgs';\nimport * as Verb from '@taqueria/protocol/Verb';\nimport { z } from 'zod';\n\nconst handlerSchema = z.union([\n\tz.string().min(1),\n\tz.function().args(RequestArgs.schemas.schema).returns(z.union([\n\t\tz.void(),\n\t\tPluginJsonResponse.schemas.schema,\n\t\tPluginJsonResponse.schemas.internalSchema,\n\t\tz.promise(\n\t\t\tz.union([\n\t\t\t\tz.promise(z.void()),\n\t\t\t\tz.void(),\n\t\t\t\tPluginJsonResponse.schemas.schema,\n\t\t\t\tPluginJsonResponse.schemas.internalSchema,\n\t\t\t]),\n\t\t),\n\t])),\n]);\n\nexport const rawSchema = z.object({\n\ttemplate: Verb.rawSchema,\n\tcommand: Command.rawSchema,\n\tdescription: z.string().min(4),\n\thidden: z.preprocess(\n\t\tval => val ?? false,\n\t\tz.boolean(),\n\t).optional(),\n\toptions: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(Option.rawSchema),\n\t).optional(),\n\tpositionals: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(PositionalArg.rawSchema),\n\t).optional(),\n\thandler: handlerSchema.describe('Template Handler'),\n\tencoding: PluginResponseEncoding.schemas.schema.optional(),\n});\n\nexport const internalSchema = rawSchema.extend({\n\ttemplate: Verb.schemas.schema,\n\tcommand: Command.schemas.schema,\n\toptions: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(Option.schemas.schema),\n\t).optional(),\n\tpositionals: z.preprocess(\n\t\tval => val ?? [],\n\t\tz.array(PositionalArg.schemas.schema),\n\t).optional(),\n});\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) => `The following template is invalid: ${value}`,\n\tunknownErrMsg: 'Something went wrong trying to parse the template',\n});\n\nexport type Template = z.infer<typeof generatedSchemas.schema>;\nexport type t = Template;\nexport const { create, make, of } = factory;\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as unknown as Template),\n};\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,YAAY,aAAa;AACzB,YAAY,YAAY;AACxB,YAAY,wBAAwB;AACpC,YAAY,4BAA4B;AACxC,YAAY,mBAAmB;AAC/B,YAAY,iBAAiB;AAC7B,YAAY,UAAU;AACtB,SAAS,SAAS;AAElB,IAAM,gBAAgB,EAAE,MAAM;AAAA,EAC7B,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EAChB,EAAE,SAAS,EAAE,KAAiB,oBAAQ,MAAM,EAAE,QAAQ,EAAE,MAAM;AAAA,IAC7D,EAAE,KAAK;AAAA,IACY,2BAAQ;AAAA,IACR,2BAAQ;AAAA,IAC3B,EAAE;AAAA,MACD,EAAE,MAAM;AAAA,QACP,EAAE,QAAQ,EAAE,KAAK,CAAC;AAAA,QAClB,EAAE,KAAK;AAAA,QACY,2BAAQ;AAAA,QACR,2BAAQ;AAAA,MAC5B,CAAC;AAAA,IACF;AAAA,EACD,CAAC,CAAC;AACH,CAAC;AAEM,IAAMA,aAAY,EAAE,OAAO;AAAA,EACjC,UAAe;AAAA,EACf,SAAiB;AAAA,EACjB,aAAa,EAAE,OAAO,EAAE,IAAI,CAAC;AAAA,EAC7B,QAAQ,EAAE;AAAA,IACT,SAAO,OAAO;AAAA,IACd,EAAE,QAAQ;AAAA,EACX,EAAE,SAAS;AAAA,EACX,SAAS,EAAE;AAAA,IACV,SAAO,OAAO,CAAC;AAAA,IACf,EAAE,MAAa,gBAAS;AAAA,EACzB,EAAE,SAAS;AAAA,EACX,aAAa,EAAE;AAAA,IACd,SAAO,OAAO,CAAC;AAAA,IACf,EAAE,MAAoB,uBAAS;AAAA,EAChC,EAAE,SAAS;AAAA,EACX,SAAS,cAAc,SAAS,kBAAkB;AAAA,EAClD,UAAiC,+BAAQ,OAAO,SAAS;AAC1D,CAAC;AAEM,IAAM,iBAAiBA,WAAU,OAAO;AAAA,EAC9C,UAAe,aAAQ;AAAA,EACvB,SAAiB,gBAAQ;AAAA,EACzB,SAAS,EAAE;AAAA,IACV,SAAO,OAAO,CAAC;AAAA,IACf,EAAE,MAAa,eAAQ,MAAM;AAAA,EAC9B,EAAE,SAAS;AAAA,EACX,aAAa,EAAE;AAAA,IACd,SAAO,OAAO,CAAC;AAAA,IACf,EAAE,MAAoB,sBAAQ,MAAM;AAAA,EACrC,EAAE,SAAS;AACZ,CAAC;AAKM,IAAM,EAAE,SAAS,kBAAkB,QAAQ,IAAI,WAA4B;AAAA,EACjF,WAAAA;AAAA,EACA;AAAA,EACA,aAAa,CAAC,UAAmB,sCAAsC;AAAA,EACvE,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,MAAM,GAAG,IAAI;AAC7B,IAAMC,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAA0B;AAC5E;","names":["rawSchema","schemas"]}

package/Timestamp.d.ts

@@ -1,2 +1,44 @@
-export * from '@taqueria/protocol/out/types/Timestamp';
+import { z } from 'zod';
+export declare const rawSchema: z.ZodNumber;
+export declare const factory: {
+    make: (input: number) => import("fluture").FutureInstance<import("./TaqError").TaqError, number & {
+        readonly __kind: any;
+    }>;
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, number & {
+        readonly __kind: any;
+    }>;
+    create: (input: number) => number & {
+        readonly __kind: any;
+    };
+    from: (input: unknown) => number & {
+        readonly __kind: any;
+    };
+}, generatedSchemas: {
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    schema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, number & {
+        readonly __kind: any;
+    }, any>;
+};
+export type Timestamp = z.infer<typeof generatedSchemas.schema>;
+export type t = Timestamp;
+export declare const create: (input: number) => number & {
+    readonly __kind: any;
+}, make: (input: number) => import("fluture").FutureInstance<import("./TaqError").TaqError, number & {
+    readonly __kind: any;
+}>, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, number & {
+    readonly __kind: any;
+}>;
+export declare const schemas: {
+    schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, number & {
+        readonly __kind: any;
+    }, any>, number & {
+        readonly __kind: any;
+    }, any>;
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+};
+export declare const now: () => number & {
+    readonly __kind: any;
+};
 //# sourceMappingURL=Timestamp.d.ts.map

package/Timestamp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Timestamp.d.ts","sourceRoot":"","sources":["Timestamp.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAC"}
+{"version":3,"file":"Timestamp.d.ts","sourceRoot":"","sources":["Timestamp.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS,aAEL,CAAC;AAIlB,eAAO,MAAQ,OAAO;;;;;;;;;;;;;GAAW,gBAAgB;;;;;;CAK/C,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAChE,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;AAC1B,eAAO,MAAQ,MAAM;;GAAE,IAAI;;IAAE,EAAE;;EAAY,CAAC;AAC5C,eAAO,MAAM,OAAO;;;;;;;;CAGnB,CAAC;AAEF,eAAO,MAAM,GAAG;;CAAgC,CAAC"}

package/Timestamp.js

@@ -1,8 +1,14 @@
 "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))
@@ -11,11 +17,49 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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);
 
 // Timestamp.ts
 var Timestamp_exports = {};
+__export(Timestamp_exports, {
+  create: () => create,
+  factory: () => factory,
+  generatedSchemas: () => generatedSchemas,
+  make: () => make,
+  now: () => now,
+  of: () => of,
+  rawSchema: () => rawSchema,
+  schemas: () => schemas
+});
 module.exports = __toCommonJS(Timestamp_exports);
-__reExport(Timestamp_exports, require("@taqueria/protocol/out/types/Timestamp"), module.exports);
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var import_zod = require("zod");
+var rawSchema = import_zod.z.number({ description: "Timestamp" }).min(1651846877);
+var { factory, schemas: generatedSchemas } = (0, import_Base.default)({
+  isStringLike: true,
+  rawSchema,
+  parseErrMsg: (value) => `${value} is an invalid timestamp`,
+  unknownErrMsg: `Something went wrong trying to parse a timestamp`
+});
+var { create, make, of } = factory;
+var schemas = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+var now = () => Date.now();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  create,
+  factory,
+  generatedSchemas,
+  make,
+  now,
+  of,
+  rawSchema,
+  schemas
+});
 //# sourceMappingURL=Timestamp.js.map

package/Timestamp.js.map

@@ -1 +1 @@
-{"version":3,"sources":["Timestamp.ts"],"sourcesContent":["export * from '@taqueria/protocol/out/types/Timestamp';\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,8BAAc,mDAAd;","names":[]}
+{"version":3,"sources":["Timestamp.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nexport const rawSchema = z\n\t.number({ description: 'Timestamp' })\n\t.min(1651846877);\n\ntype Input = z.infer<typeof rawSchema>;\n\nexport const { factory, schemas: generatedSchemas } = createType<Input, Input>({\n\tisStringLike: true,\n\trawSchema,\n\tparseErrMsg: (value: unknown) => `${value} is an invalid timestamp`,\n\tunknownErrMsg: `Something went wrong trying to parse a timestamp`,\n});\n\nexport type Timestamp = z.infer<typeof generatedSchemas.schema>;\nexport type t = Timestamp;\nexport const { create, make, of } = factory;\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as Timestamp),\n};\n\nexport const now = () => Date.now() as Timestamp;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAuB;AACvB,iBAAkB;AAEX,IAAM,YAAY,aACvB,OAAO,EAAE,aAAa,YAAY,CAAC,EACnC,IAAI,UAAU;AAIT,IAAM,EAAE,SAAS,SAAS,iBAAiB,QAAI,YAAAA,SAAyB;AAAA,EAC9E,cAAc;AAAA,EACd;AAAA,EACA,aAAa,CAAC,UAAmB,GAAG;AAAA,EACpC,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,MAAM,GAAG,IAAI;AAC7B,IAAM,UAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAgB;AAClE;AAEO,IAAM,MAAM,MAAM,KAAK,IAAI;","names":["createType"]}

package/Timestamp.mjs

@@ -1,3 +1,27 @@
 // Timestamp.ts
-export * from "@taqueria/protocol/out/types/Timestamp";
+import createType from "@taqueria/protocol/Base";
+import { z } from "zod";
+var rawSchema = z.number({ description: "Timestamp" }).min(1651846877);
+var { factory, schemas: generatedSchemas } = createType({
+  isStringLike: true,
+  rawSchema,
+  parseErrMsg: (value) => `${value} is an invalid timestamp`,
+  unknownErrMsg: `Something went wrong trying to parse a timestamp`
+});
+var { create, make, of } = factory;
+var schemas = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+var now = () => Date.now();
+export {
+  create,
+  factory,
+  generatedSchemas,
+  make,
+  now,
+  of,
+  rawSchema,
+  schemas
+};
 //# sourceMappingURL=Timestamp.mjs.map

package/Timestamp.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["Timestamp.ts"],"sourcesContent":["export * from '@taqueria/protocol/out/types/Timestamp';\n"],"mappings":";AAAA,cAAc;","names":[]}
+{"version":3,"sources":["Timestamp.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nexport const rawSchema = z\n\t.number({ description: 'Timestamp' })\n\t.min(1651846877);\n\ntype Input = z.infer<typeof rawSchema>;\n\nexport const { factory, schemas: generatedSchemas } = createType<Input, Input>({\n\tisStringLike: true,\n\trawSchema,\n\tparseErrMsg: (value: unknown) => `${value} is an invalid timestamp`,\n\tunknownErrMsg: `Something went wrong trying to parse a timestamp`,\n});\n\nexport type Timestamp = z.infer<typeof generatedSchemas.schema>;\nexport type t = Timestamp;\nexport const { create, make, of } = factory;\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as Timestamp),\n};\n\nexport const now = () => Date.now() as Timestamp;\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,SAAS,SAAS;AAEX,IAAM,YAAY,EACvB,OAAO,EAAE,aAAa,YAAY,CAAC,EACnC,IAAI,UAAU;AAIT,IAAM,EAAE,SAAS,SAAS,iBAAiB,IAAI,WAAyB;AAAA,EAC9E,cAAc;AAAA,EACd;AAAA,EACA,aAAa,CAAC,UAAmB,GAAG;AAAA,EACpC,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,MAAM,GAAG,IAAI;AAC7B,IAAM,UAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAgB;AAClE;AAEO,IAAM,MAAM,MAAM,KAAK,IAAI;","names":[]}

package/Tz.d.ts

@@ -1,2 +1,40 @@
-export * from '@taqueria/protocol/out/types/Tz';
+import { z } from 'zod';
+export declare const rawSchema: z.ZodString;
+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>, string & {
+        readonly __kind: any;
+    }, any>;
+}, factory: {
+    make: (input: string) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
+        readonly __kind: any;
+    }>;
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
+        readonly __kind: any;
+    }>;
+    create: (input: string) => string & {
+        readonly __kind: any;
+    };
+    from: (input: unknown) => string & {
+        readonly __kind: any;
+    };
+};
+export type Tz = z.infer<typeof generatedSchemas.schema>;
+export declare const create: (input: string) => string & {
+    readonly __kind: any;
+}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
+    readonly __kind: any;
+}>, make: (input: string) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
+    readonly __kind: any;
+}>;
+export declare const schemas: {
+    schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
+        readonly __kind: any;
+    }, any>, string & {
+        readonly __kind: any;
+    }, any>;
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+};
 //# sourceMappingURL=Tz.d.ts.map

package/Tz.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Tz.d.ts","sourceRoot":"","sources":["Tz.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"Tz.d.ts","sourceRoot":"","sources":["Tz.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS,aAAkE,CAAC;AAIzF,eAAO,MAAiB,gBAAgB;;;;;;GAAE,OAAO;;;;;;;;;;;;;CAK/C,CAAC;AAEH,MAAM,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAQ,MAAM;;GAAE,EAAE;;IAAE,IAAI;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;CAGnB,CAAC"}

package/Tz.js

@@ -1,8 +1,14 @@
 "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))
@@ -11,11 +17,46 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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);
 
 // Tz.ts
 var Tz_exports = {};
+__export(Tz_exports, {
+  create: () => create,
+  factory: () => factory,
+  generatedSchemas: () => generatedSchemas,
+  make: () => make,
+  of: () => of,
+  rawSchema: () => rawSchema,
+  schemas: () => schemas
+});
 module.exports = __toCommonJS(Tz_exports);
-__reExport(Tz_exports, require("@taqueria/protocol/out/types/Tz"), module.exports);
+var import_Base = __toESM(require("@taqueria/protocol/Base"));
+var import_zod = require("zod");
+var rawSchema = import_zod.z.string({ description: "Tz" }).min(1).regex(/^\d([\d_]+\d)?$/);
+var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
+  isStringLike: true,
+  rawSchema,
+  parseErrMsg: (value) => `${value} is an invalid Tz amount`,
+  unknownErrMsg: "Something went wrong when parsing the Tz amount"
+});
+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
+});
 //# sourceMappingURL=Tz.js.map

package/Tz.js.map

@@ -1 +1 @@
-{"version":3,"sources":["Tz.ts"],"sourcesContent":["export * from '@taqueria/protocol/out/types/Tz';\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,uBAAc,4CAAd;","names":[]}
+{"version":3,"sources":["Tz.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nexport const rawSchema = z.string({ description: 'Tz' }).min(1).regex(/^\\d([\\d_]+\\d)?$/);\n\ntype RawInput = z.infer<typeof rawSchema>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({\n\tisStringLike: true,\n\trawSchema,\n\tparseErrMsg: (value: unknown) => `${value} is an invalid Tz amount`,\n\tunknownErrMsg: 'Something went wrong when parsing the Tz amount',\n});\n\nexport type Tz = z.infer<typeof generatedSchemas.schema>;\n\nexport const { create, of, make } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as Tz),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAuB;AACvB,iBAAkB;AAEX,IAAM,YAAY,aAAE,OAAO,EAAE,aAAa,KAAK,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,iBAAiB;AAIhF,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAA,SAA+B;AAAA,EACpF,cAAc;AAAA,EACd;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,GAAS;AAC3D;","names":["createType"]}

package/Tz.mjs

@@ -1,3 +1,25 @@
 // Tz.ts
-export * from "@taqueria/protocol/out/types/Tz";
+import createType from "@taqueria/protocol/Base";
+import { z } from "zod";
+var rawSchema = z.string({ description: "Tz" }).min(1).regex(/^\d([\d_]+\d)?$/);
+var { schemas: generatedSchemas, factory } = createType({
+  isStringLike: true,
+  rawSchema,
+  parseErrMsg: (value) => `${value} is an invalid Tz amount`,
+  unknownErrMsg: "Something went wrong when parsing the Tz amount"
+});
+var { create, of, make } = factory;
+var schemas = {
+  ...generatedSchemas,
+  schema: generatedSchemas.schema.transform((val) => val)
+};
+export {
+  create,
+  factory,
+  generatedSchemas,
+  make,
+  of,
+  rawSchema,
+  schemas
+};
 //# sourceMappingURL=Tz.mjs.map

package/Tz.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["Tz.ts"],"sourcesContent":["export * from '@taqueria/protocol/out/types/Tz';\n"],"mappings":";AAAA,cAAc;","names":[]}
+{"version":3,"sources":["Tz.ts"],"sourcesContent":["import createType from '@taqueria/protocol/Base';\nimport { z } from 'zod';\n\nexport const rawSchema = z.string({ description: 'Tz' }).min(1).regex(/^\\d([\\d_]+\\d)?$/);\n\ntype RawInput = z.infer<typeof rawSchema>;\n\nexport const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({\n\tisStringLike: true,\n\trawSchema,\n\tparseErrMsg: (value: unknown) => `${value} is an invalid Tz amount`,\n\tunknownErrMsg: 'Something went wrong when parsing the Tz amount',\n});\n\nexport type Tz = z.infer<typeof generatedSchemas.schema>;\n\nexport const { create, of, make } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as Tz),\n};\n"],"mappings":";AAAA,OAAO,gBAAgB;AACvB,SAAS,SAAS;AAEX,IAAM,YAAY,EAAE,OAAO,EAAE,aAAa,KAAK,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,iBAAiB;AAIhF,IAAM,EAAE,SAAS,kBAAkB,QAAQ,IAAI,WAA+B;AAAA,EACpF,cAAc;AAAA,EACd;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,GAAS;AAC3D;","names":[]}

package/Url.d.ts

@@ -1,2 +1,42 @@
-export * from '@taqueria/protocol/out/types/Url';
+import { z } from 'zod';
+export declare const rawSchema: z.ZodString;
+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>, string & {
+        readonly __kind: any;
+    }, any>;
+}, factory: {
+    make: (input: string) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
+        readonly __kind: any;
+    }>;
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
+        readonly __kind: any;
+    }>;
+    create: (input: string) => string & {
+        readonly __kind: any;
+    };
+    from: (input: unknown) => string & {
+        readonly __kind: any;
+    };
+};
+export declare const toComponents: (url: Url) => URL;
+export type Url = z.infer<typeof generatedSchemas.schema>;
+export type t = Url;
+export declare const create: (input: string) => string & {
+    readonly __kind: any;
+}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
+    readonly __kind: any;
+}>, make: (input: string) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
+    readonly __kind: any;
+}>;
+export declare const schemas: {
+    schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
+        readonly __kind: any;
+    }, any>, string & {
+        readonly __kind: any;
+    }, any>;
+    rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
+    internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
+};
 //# sourceMappingURL=Url.d.ts.map

package/Url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Url.d.ts","sourceRoot":"","sources":["Url.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"Url.d.ts","sourceRoot":"","sources":["Url.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS,aAEf,CAAC;AAIR,eAAO,MAAiB,gBAAgB;;;;;;GAAE,OAAO;;;;;;;;;;;;;CAK/C,CAAC;AAEH,eAAO,MAAM,YAAY,QAAS,GAAG,QAGpC,CAAC;AAEF,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAC1D,MAAM,MAAM,CAAC,GAAG,GAAG,CAAC;AACpB,eAAO,MAAQ,MAAM;;GAAE,EAAE;;IAAE,IAAI;;EAAY,CAAC;AAC5C,eAAO,MAAM,OAAO;;;;;;;;CAGnB,CAAC"}