@taqueria/protocol 0.18.0 → 0.19.3

package/EphemeralState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EphemeralState.d.ts","sourceRoot":"","sources":["EphemeralState.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,2BAA2B,CAAC;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAKpD,OAAO,KAAK,UAAU,MAAM,+BAA+B,CAAC;AAE5D,OAAO,EAAc,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAGnE,OAAO,EAAY,cAAc,IAAI,MAAM,EAAmB,MAAM,SAAS,CAAC;AAC9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAKpB,CAAC;AACF,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAKzB,CAAC;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAKxB,CAAC;AAaF,eAAO,MAAiB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/Faucet.d.ts

@@ -1,210 +1,204 @@
-import * as fluture from 'fluture';
-import { TaqError } from './TaqError.js';
 import { Flatten } from '@taqueria/protocol/Base';
 import { z } from 'zod';
-
-declare const rawSchema: z.ZodObject<{
+export declare const rawSchema: z.ZodObject<z.extendShape<{
+    mnemonic: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], unknown>;
+    email: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    activation_code: z.ZodOptional<z.ZodString>;
+}, {
     pkh: z.ZodString;
-    mnemonic: z.ZodArray<z.ZodString, "many">;
-    email: z.ZodString;
-    password: z.ZodString;
-    amount: z.ZodString;
-    activation_code: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    pkh: string;
+}>, "strip", z.ZodTypeAny, {
+    email?: string | undefined;
+    password?: string | undefined;
+    amount?: string | undefined;
+    activation_code?: string | undefined;
     mnemonic: string[];
-    email: string;
-    password: string;
-    amount: string;
-    activation_code: string;
+    pkh: string;
 }, {
+    mnemonic?: unknown;
+    email?: string | undefined;
+    password?: string | undefined;
+    amount?: string | undefined;
+    activation_code?: string | undefined;
     pkh: string;
-    mnemonic: string[];
-    email: string;
-    password: string;
-    amount: string;
-    activation_code: string;
 }>;
-declare const generatedSchemas: {
+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>, {
+        email?: string | undefined;
+        password?: string | undefined;
+        amount?: string | undefined;
+        activation_code?: string | undefined;
+        mnemonic: string[];
         pkh: string & {
             readonly __kind: any;
         };
-        mnemonic: string[];
-        email: string;
-        password: string;
-        amount: string;
-        activation_code: string;
     } & {
         readonly __kind: any;
     }, any>;
-};
-declare const factory: {
+}, factory: {
     make: (input: {
+        email?: string | undefined;
+        password?: string | undefined;
+        amount?: string | undefined;
+        activation_code?: string | undefined;
+        mnemonic: string[];
         pkh: string & {
             readonly __kind: any;
         };
+    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        email?: string | undefined;
+        password?: string | undefined;
+        amount?: string | undefined;
+        activation_code?: string | undefined;
         mnemonic: string[];
-        email: string;
-        password: string;
-        amount: string;
-        activation_code: string;
-    }) => fluture.FutureInstance<TaqError, {
         pkh: string & {
             readonly __kind: any;
         };
-        mnemonic: string[];
-        email: string;
-        password: string;
-        amount: string;
-        activation_code: string;
     } & {
         readonly __kind: any;
     }>;
-    of: (input: unknown) => fluture.FutureInstance<TaqError, {
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        email?: string | undefined;
+        password?: string | undefined;
+        amount?: string | undefined;
+        activation_code?: string | undefined;
+        mnemonic: string[];
         pkh: string & {
             readonly __kind: any;
         };
-        mnemonic: string[];
-        email: string;
-        password: string;
-        amount: string;
-        activation_code: string;
     } & {
         readonly __kind: any;
     }>;
     create: (input: {
-        pkh: string;
+        email?: string | undefined;
+        password?: string | undefined;
+        amount?: string | undefined;
+        activation_code?: string | undefined;
         mnemonic: string[];
-        email: string;
-        password: string;
-        amount: string;
-        activation_code: string;
+        pkh: string;
     } | {
+        email?: string | undefined;
+        password?: string | undefined;
+        amount?: string | undefined;
+        activation_code?: string | undefined;
+        mnemonic: string[];
         pkh: string & {
             readonly __kind: any;
         };
-        mnemonic: string[];
-        email: string;
-        password: string;
-        amount: string;
-        activation_code: string;
     }) => {
+        email?: string | undefined;
+        password?: string | undefined;
+        amount?: string | undefined;
+        activation_code?: string | undefined;
+        mnemonic: string[];
         pkh: string & {
             readonly __kind: any;
         };
-        mnemonic: string[];
-        email: string;
-        password: string;
-        amount: string;
-        activation_code: string;
     } & {
         readonly __kind: any;
     };
     from: (input: unknown) => {
+        email?: string | undefined;
+        password?: string | undefined;
+        amount?: string | undefined;
+        activation_code?: string | undefined;
+        mnemonic: string[];
         pkh: string & {
             readonly __kind: any;
         };
-        mnemonic: string[];
-        email: string;
-        password: string;
-        amount: string;
-        activation_code: string;
     } & {
         readonly __kind: any;
     };
 };
-declare type Faucet = Flatten<z.infer<typeof generatedSchemas.schema>>;
-declare type t = Faucet;
-declare const create: (input: {
-    pkh: string;
+export declare type Faucet = Flatten<z.infer<typeof generatedSchemas.schema>>;
+export declare type t = Faucet;
+export declare const create: (input: {
+    email?: string | undefined;
+    password?: string | undefined;
+    amount?: string | undefined;
+    activation_code?: string | undefined;
     mnemonic: string[];
-    email: string;
-    password: string;
-    amount: string;
-    activation_code: string;
+    pkh: string;
 } | {
+    email?: string | undefined;
+    password?: string | undefined;
+    amount?: string | undefined;
+    activation_code?: string | undefined;
+    mnemonic: string[];
     pkh: string & {
         readonly __kind: any;
     };
-    mnemonic: string[];
-    email: string;
-    password: string;
-    amount: string;
-    activation_code: string;
 }) => {
+    email?: string | undefined;
+    password?: string | undefined;
+    amount?: string | undefined;
+    activation_code?: string | undefined;
+    mnemonic: string[];
     pkh: string & {
         readonly __kind: any;
     };
-    mnemonic: string[];
-    email: string;
-    password: string;
-    amount: string;
-    activation_code: string;
 } & {
     readonly __kind: any;
-};
-declare const of: (input: unknown) => fluture.FutureInstance<TaqError, {
+}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+    email?: string | undefined;
+    password?: string | undefined;
+    amount?: string | undefined;
+    activation_code?: string | undefined;
+    mnemonic: string[];
     pkh: string & {
         readonly __kind: any;
     };
-    mnemonic: string[];
-    email: string;
-    password: string;
-    amount: string;
-    activation_code: string;
 } & {
     readonly __kind: any;
-}>;
-declare const make: (input: {
+}>, make: (input: {
+    email?: string | undefined;
+    password?: string | undefined;
+    amount?: string | undefined;
+    activation_code?: string | undefined;
+    mnemonic: string[];
     pkh: string & {
         readonly __kind: any;
     };
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+    email?: string | undefined;
+    password?: string | undefined;
+    amount?: string | undefined;
+    activation_code?: string | undefined;
     mnemonic: string[];
-    email: string;
-    password: string;
-    amount: string;
-    activation_code: string;
-}) => fluture.FutureInstance<TaqError, {
     pkh: string & {
         readonly __kind: any;
     };
-    mnemonic: string[];
-    email: string;
-    password: string;
-    amount: string;
-    activation_code: string;
 } & {
     readonly __kind: any;
 }>;
-declare const schemas: {
+export declare const schemas: {
     schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
+        email?: string | undefined;
+        password?: string | undefined;
+        amount?: string | undefined;
+        activation_code?: string | undefined;
+        mnemonic: string[];
         pkh: string & {
             readonly __kind: any;
         };
-        mnemonic: string[];
-        email: string;
-        password: string;
-        amount: string;
-        activation_code: string;
     } & {
         readonly __kind: any;
     }, any>, Flatten<{
+        email?: string | undefined;
+        password?: string | undefined;
+        amount?: string | undefined;
+        activation_code?: string | undefined;
+        mnemonic: string[];
         pkh: string & {
             readonly __kind: any;
         };
-        mnemonic: string[];
-        email: string;
-        password: string;
-        amount: string;
-        activation_code: string;
     } & {
         readonly __kind: any;
     }>, any>;
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
 };
-
-export { Faucet, create, factory, generatedSchemas, make, of, rawSchema, schemas, t };
+//# sourceMappingURL=Faucet.d.ts.map

package/Faucet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Faucet.d.ts","sourceRoot":"","sources":["Faucet.ts"],"names":[],"mappings":"AAAA,OAAmB,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmBxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;EAED,CAAC;AAuBtB,eAAO,MAAiB,gBAAgB;;;;;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK/C,CAAC;AAEH,oBAAY,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;AACtE,oBAAY,CAAC,GAAG,MAAM,CAAC;AACvB,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,EAAE;;;;;;;;;;;IAAE,IAAI;;;;;;;;;;;;;;;;;;;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC"}

package/Faucet.js

@@ -38,28 +38,40 @@ module.exports = __toCommonJS(Faucet_exports);
 var import_Base = __toESM(require("@taqueria/protocol/Base"));
 var PublicKeyHash = __toESM(require("@taqueria/protocol/PublicKeyHash"));
 var import_zod = require("zod");
-var rawSchema = import_zod.z.object({
-  pkh: import_zod.z.string({ description: "Faucet Public Key Hash" }).min(1),
-  mnemonic: import_zod.z.array(
-    import_zod.z.string({ description: "Faucet Mnemonic Word" }).min(1),
-    { description: "Faucet Mnemonic" }
+var commonSchema = import_zod.z.object({
+  mnemonic: import_zod.z.preprocess(
+    (arg) => typeof arg === "string" ? arg.split(" ") : arg,
+    import_zod.z.array(
+      import_zod.z.string({ description: "Faucet Mnemonic Word" }).min(1).regex(/^[a-z]{2,}$/),
+      { description: "Faucet Mnemonic" }
+    )
   ),
-  email: import_zod.z.string({ description: "Faucet E-mail" }).regex(/^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/),
-  password: import_zod.z.string({ description: "Faucet Password" }).min(1),
-  amount: import_zod.z.string({ description: "Faucet Account" }).min(1).regex(/^\d+$/),
-  activation_code: import_zod.z.string({ description: "Faucet Activation Code" }).min(1)
-}).describe("Faucet");
-var internalSchema = import_zod.z.object({
-  pkh: PublicKeyHash.schemas.schema,
-  mnemonic: import_zod.z.array(
-    import_zod.z.string({ description: "Faucet Mnemonic Word" }).nonempty().regex(/^[a-z]{2,}$/),
-    { description: "Faucet Mnemonic" }
-  ),
-  email: import_zod.z.string({ description: "Faucet E-mail" }).regex(/^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/),
-  password: import_zod.z.string({ description: "Faucet Password" }).nonempty(),
-  amount: import_zod.z.string({ description: "Faucet Account" }).nonempty().regex(/^\d+$/),
-  activation_code: import_zod.z.string({ description: "Faucet Activation Code" }).nonempty()
+  email: import_zod.z.string({ description: "Faucet E-mail" }).regex(/^([\w-\.]+@([\w-]+\.)+[\w-]{2,4})?$/).optional(),
+  password: import_zod.z.string({ description: "Faucet Password" }).optional(),
+  amount: import_zod.z.string({ description: "Faucet Amount" }).refine(
+    (val) => val.length === 0 || /^\d+$/.test(val),
+    "Amount, if present, must be numeric"
+  ).optional(),
+  activation_code: import_zod.z.string({ description: "Faucet Activation Code" }).optional()
+});
+var rawSchema = commonSchema.extend({
+  pkh: import_zod.z.string({ description: "Faucet Public Key Hash" }).min(1)
 }).describe("Faucet");
+var internalSchema = import_zod.z.preprocess(
+  (input) => {
+    const defaults = {
+      pkh: "",
+      mnemonic: [],
+      email: "",
+      password: "",
+      activation_code: ""
+    };
+    return typeof input === "object" ? { ...defaults, ...input } : defaults;
+  },
+  commonSchema.extend({
+    pkh: PublicKeyHash.schemas.schema
+  })
+).describe("Faucet");
 var { schemas: generatedSchemas, factory } = (0, import_Base.default)({
   rawSchema,
   internalSchema,

package/Faucet.js.map

@@ -1 +1 @@
-{"version":3,"sources":["Faucet.ts"],"sourcesContent":["import createType, { Flatten } from '@taqueria/protocol/Base';\nimport * as PublicKeyHash from '@taqueria/protocol/PublicKeyHash';\nimport { z } from 'zod';\n\nexport const rawSchema = z.object({\n\tpkh: z.string({ description: 'Faucet Public Key Hash' }).min(1),\n\tmnemonic: z.array(\n\t\tz.string({ description: 'Faucet Mnemonic Word' }).min(1),\n\t\t{ description: 'Faucet Mnemonic' },\n\t),\n\temail: z.string({ description: 'Faucet E-mail' }).regex(/^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$/),\n\tpassword: z.string({ description: 'Faucet Password' }).min(1),\n\tamount: z.string({ description: 'Faucet Account' }).min(1).regex(/^\\d+$/),\n\tactivation_code: z.string({ description: 'Faucet Activation Code' }).min(1),\n}).describe('Faucet');\n\nconst internalSchema = z.object({\n\tpkh: PublicKeyHash.schemas.schema,\n\tmnemonic: z.array(\n\t\tz.string({ description: 'Faucet Mnemonic Word' }).nonempty().regex(/^[a-z]{2,}$/),\n\t\t{ description: 'Faucet Mnemonic' },\n\t),\n\temail: z.string({ description: 'Faucet E-mail' }).regex(/^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$/),\n\tpassword: z.string({ description: 'Faucet Password' }).nonempty(),\n\tamount: z.string({ description: 'Faucet Account' }).nonempty().regex(/^\\d+$/),\n\tactivation_code: z.string({ description: 'Faucet Activation Code' }).nonempty(),\n}).describe('Faucet');\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 faucet configuration`,\n\tunknownErrMsg: 'Something went wrong trying to parse the faucet',\n});\n\nexport type Faucet = Flatten<z.infer<typeof generatedSchemas.schema>>;\nexport type t = Faucet;\nexport const { create, of, make } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as Faucet),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAAA;AAAA;AAAA;AAAA,kBAAoC;AACpC,oBAA+B;AAC/B,iBAAkB;AAEX,IAAM,YAAY,aAAE,OAAO;AAAA,EACjC,KAAK,aAAE,OAAO,EAAE,aAAa,yBAAyB,CAAC,EAAE,IAAI,CAAC;AAAA,EAC9D,UAAU,aAAE;AAAA,IACX,aAAE,OAAO,EAAE,aAAa,uBAAuB,CAAC,EAAE,IAAI,CAAC;AAAA,IACvD,EAAE,aAAa,kBAAkB;AAAA,EAClC;AAAA,EACA,OAAO,aAAE,OAAO,EAAE,aAAa,gBAAgB,CAAC,EAAE,MAAM,kCAAkC;AAAA,EAC1F,UAAU,aAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,IAAI,CAAC;AAAA,EAC5D,QAAQ,aAAE,OAAO,EAAE,aAAa,iBAAiB,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,OAAO;AAAA,EACxE,iBAAiB,aAAE,OAAO,EAAE,aAAa,yBAAyB,CAAC,EAAE,IAAI,CAAC;AAC3E,CAAC,EAAE,SAAS,QAAQ;AAEpB,IAAM,iBAAiB,aAAE,OAAO;AAAA,EAC/B,KAAmB,sBAAQ;AAAA,EAC3B,UAAU,aAAE;AAAA,IACX,aAAE,OAAO,EAAE,aAAa,uBAAuB,CAAC,EAAE,SAAS,EAAE,MAAM,aAAa;AAAA,IAChF,EAAE,aAAa,kBAAkB;AAAA,EAClC;AAAA,EACA,OAAO,aAAE,OAAO,EAAE,aAAa,gBAAgB,CAAC,EAAE,MAAM,kCAAkC;AAAA,EAC1F,UAAU,aAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,SAAS;AAAA,EAChE,QAAQ,aAAE,OAAO,EAAE,aAAa,iBAAiB,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO;AAAA,EAC5E,iBAAiB,aAAE,OAAO,EAAE,aAAa,yBAAyB,CAAC,EAAE,SAAS;AAC/E,CAAC,EAAE,SAAS,QAAQ;AAKb,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAC,SAA4B;AAAA,EACjF;AAAA,EACA;AAAA,EACA,aAAa,CAAC,UAAmB,GAAG;AAAA,EACpC,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAE7B,IAAMD,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAa;AAC/D;","names":["schemas","createType"]}
+{"version":3,"sources":["Faucet.ts"],"sourcesContent":["import createType, { Flatten } from '@taqueria/protocol/Base';\nimport * as PublicKeyHash from '@taqueria/protocol/PublicKeyHash';\nimport { z } from 'zod';\n\nconst commonSchema = z.object({\n\tmnemonic: z.preprocess(\n\t\targ => typeof arg === 'string' ? arg.split(' ') : arg,\n\t\tz.array(\n\t\t\tz.string({ description: 'Faucet Mnemonic Word' }).min(1).regex(/^[a-z]{2,}$/),\n\t\t\t{ description: 'Faucet Mnemonic' },\n\t\t),\n\t),\n\temail: z.string({ description: 'Faucet E-mail' }).regex(/^([\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4})?$/).optional(),\n\tpassword: z.string({ description: 'Faucet Password' }).optional(),\n\tamount: z.string({ description: 'Faucet Amount' }).refine(\n\t\tval => val.length === 0 || /^\\d+$/.test(val),\n\t\t'Amount, if present, must be numeric',\n\t).optional(),\n\tactivation_code: z.string({ description: 'Faucet Activation Code' }).optional(),\n});\n\nexport const rawSchema = commonSchema.extend({\n\tpkh: z.string({ description: 'Faucet Public Key Hash' }).min(1),\n}).describe('Faucet');\n\nconst internalSchema = z.preprocess(\n\tinput => {\n\t\tconst defaults = {\n\t\t\tpkh: '',\n\t\t\tmnemonic: [],\n\t\t\temail: '',\n\t\t\tpassword: '',\n\t\t\tactivation_code: '',\n\t\t};\n\t\treturn typeof input === 'object'\n\t\t\t? { ...defaults, ...input }\n\t\t\t: defaults;\n\t},\n\tcommonSchema.extend({\n\t\tpkh: PublicKeyHash.schemas.schema,\n\t}),\n).describe('Faucet');\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 faucet configuration`,\n\tunknownErrMsg: 'Something went wrong trying to parse the faucet',\n});\n\nexport type Faucet = Flatten<z.infer<typeof generatedSchemas.schema>>;\nexport type t = Faucet;\nexport const { create, of, make } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as Faucet),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAAA;AAAA;AAAA;AAAA,kBAAoC;AACpC,oBAA+B;AAC/B,iBAAkB;AAElB,IAAM,eAAe,aAAE,OAAO;AAAA,EAC7B,UAAU,aAAE;AAAA,IACX,SAAO,OAAO,QAAQ,WAAW,IAAI,MAAM,GAAG,IAAI;AAAA,IAClD,aAAE;AAAA,MACD,aAAE,OAAO,EAAE,aAAa,uBAAuB,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,aAAa;AAAA,MAC5E,EAAE,aAAa,kBAAkB;AAAA,IAClC;AAAA,EACD;AAAA,EACA,OAAO,aAAE,OAAO,EAAE,aAAa,gBAAgB,CAAC,EAAE,MAAM,qCAAqC,EAAE,SAAS;AAAA,EACxG,UAAU,aAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,SAAS;AAAA,EAChE,QAAQ,aAAE,OAAO,EAAE,aAAa,gBAAgB,CAAC,EAAE;AAAA,IAClD,SAAO,IAAI,WAAW,KAAK,QAAQ,KAAK,GAAG;AAAA,IAC3C;AAAA,EACD,EAAE,SAAS;AAAA,EACX,iBAAiB,aAAE,OAAO,EAAE,aAAa,yBAAyB,CAAC,EAAE,SAAS;AAC/E,CAAC;AAEM,IAAM,YAAY,aAAa,OAAO;AAAA,EAC5C,KAAK,aAAE,OAAO,EAAE,aAAa,yBAAyB,CAAC,EAAE,IAAI,CAAC;AAC/D,CAAC,EAAE,SAAS,QAAQ;AAEpB,IAAM,iBAAiB,aAAE;AAAA,EACxB,WAAS;AACR,UAAM,WAAW;AAAA,MAChB,KAAK;AAAA,MACL,UAAU,CAAC;AAAA,MACX,OAAO;AAAA,MACP,UAAU;AAAA,MACV,iBAAiB;AAAA,IAClB;AACA,WAAO,OAAO,UAAU,WACrB,EAAE,GAAG,UAAU,GAAG,MAAM,IACxB;AAAA,EACJ;AAAA,EACA,aAAa,OAAO;AAAA,IACnB,KAAmB,sBAAQ;AAAA,EAC5B,CAAC;AACF,EAAE,SAAS,QAAQ;AAKZ,IAAM,EAAE,SAAS,kBAAkB,QAAQ,QAAI,YAAAC,SAA4B;AAAA,EACjF;AAAA,EACA;AAAA,EACA,aAAa,CAAC,UAAmB,GAAG;AAAA,EACpC,eAAe;AAChB,CAAC;AAIM,IAAM,EAAE,QAAQ,IAAI,KAAK,IAAI;AAE7B,IAAMD,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAa;AAC/D;","names":["schemas","createType"]}

package/Faucet.mjs

@@ -2,28 +2,40 @@
 import createType from "@taqueria/protocol/Base";
 import * as PublicKeyHash from "@taqueria/protocol/PublicKeyHash";
 import { z } from "zod";
-var rawSchema = z.object({
-  pkh: z.string({ description: "Faucet Public Key Hash" }).min(1),
-  mnemonic: z.array(
-    z.string({ description: "Faucet Mnemonic Word" }).min(1),
-    { description: "Faucet Mnemonic" }
+var commonSchema = z.object({
+  mnemonic: z.preprocess(
+    (arg) => typeof arg === "string" ? arg.split(" ") : arg,
+    z.array(
+      z.string({ description: "Faucet Mnemonic Word" }).min(1).regex(/^[a-z]{2,}$/),
+      { description: "Faucet Mnemonic" }
+    )
   ),
-  email: z.string({ description: "Faucet E-mail" }).regex(/^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/),
-  password: z.string({ description: "Faucet Password" }).min(1),
-  amount: z.string({ description: "Faucet Account" }).min(1).regex(/^\d+$/),
-  activation_code: z.string({ description: "Faucet Activation Code" }).min(1)
-}).describe("Faucet");
-var internalSchema = z.object({
-  pkh: PublicKeyHash.schemas.schema,
-  mnemonic: z.array(
-    z.string({ description: "Faucet Mnemonic Word" }).nonempty().regex(/^[a-z]{2,}$/),
-    { description: "Faucet Mnemonic" }
-  ),
-  email: z.string({ description: "Faucet E-mail" }).regex(/^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/),
-  password: z.string({ description: "Faucet Password" }).nonempty(),
-  amount: z.string({ description: "Faucet Account" }).nonempty().regex(/^\d+$/),
-  activation_code: z.string({ description: "Faucet Activation Code" }).nonempty()
+  email: z.string({ description: "Faucet E-mail" }).regex(/^([\w-\.]+@([\w-]+\.)+[\w-]{2,4})?$/).optional(),
+  password: z.string({ description: "Faucet Password" }).optional(),
+  amount: z.string({ description: "Faucet Amount" }).refine(
+    (val) => val.length === 0 || /^\d+$/.test(val),
+    "Amount, if present, must be numeric"
+  ).optional(),
+  activation_code: z.string({ description: "Faucet Activation Code" }).optional()
+});
+var rawSchema = commonSchema.extend({
+  pkh: z.string({ description: "Faucet Public Key Hash" }).min(1)
 }).describe("Faucet");
+var internalSchema = z.preprocess(
+  (input) => {
+    const defaults = {
+      pkh: "",
+      mnemonic: [],
+      email: "",
+      password: "",
+      activation_code: ""
+    };
+    return typeof input === "object" ? { ...defaults, ...input } : defaults;
+  },
+  commonSchema.extend({
+    pkh: PublicKeyHash.schemas.schema
+  })
+).describe("Faucet");
 var { schemas: generatedSchemas, factory } = createType({
   rawSchema,
   internalSchema,

package/Faucet.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["Faucet.ts"],"sourcesContent":["import createType, { Flatten } from '@taqueria/protocol/Base';\nimport * as PublicKeyHash from '@taqueria/protocol/PublicKeyHash';\nimport { z } from 'zod';\n\nexport const rawSchema = z.object({\n\tpkh: z.string({ description: 'Faucet Public Key Hash' }).min(1),\n\tmnemonic: z.array(\n\t\tz.string({ description: 'Faucet Mnemonic Word' }).min(1),\n\t\t{ description: 'Faucet Mnemonic' },\n\t),\n\temail: z.string({ description: 'Faucet E-mail' }).regex(/^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$/),\n\tpassword: z.string({ description: 'Faucet Password' }).min(1),\n\tamount: z.string({ description: 'Faucet Account' }).min(1).regex(/^\\d+$/),\n\tactivation_code: z.string({ description: 'Faucet Activation Code' }).min(1),\n}).describe('Faucet');\n\nconst internalSchema = z.object({\n\tpkh: PublicKeyHash.schemas.schema,\n\tmnemonic: z.array(\n\t\tz.string({ description: 'Faucet Mnemonic Word' }).nonempty().regex(/^[a-z]{2,}$/),\n\t\t{ description: 'Faucet Mnemonic' },\n\t),\n\temail: z.string({ description: 'Faucet E-mail' }).regex(/^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$/),\n\tpassword: z.string({ description: 'Faucet Password' }).nonempty(),\n\tamount: z.string({ description: 'Faucet Account' }).nonempty().regex(/^\\d+$/),\n\tactivation_code: z.string({ description: 'Faucet Activation Code' }).nonempty(),\n}).describe('Faucet');\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 faucet configuration`,\n\tunknownErrMsg: 'Something went wrong trying to parse the faucet',\n});\n\nexport type Faucet = Flatten<z.infer<typeof generatedSchemas.schema>>;\nexport type t = Faucet;\nexport const { create, of, make } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as Faucet),\n};\n"],"mappings":";AAAA,OAAO,gBAA6B;AACpC,YAAY,mBAAmB;AAC/B,SAAS,SAAS;AAEX,IAAM,YAAY,EAAE,OAAO;AAAA,EACjC,KAAK,EAAE,OAAO,EAAE,aAAa,yBAAyB,CAAC,EAAE,IAAI,CAAC;AAAA,EAC9D,UAAU,EAAE;AAAA,IACX,EAAE,OAAO,EAAE,aAAa,uBAAuB,CAAC,EAAE,IAAI,CAAC;AAAA,IACvD,EAAE,aAAa,kBAAkB;AAAA,EAClC;AAAA,EACA,OAAO,EAAE,OAAO,EAAE,aAAa,gBAAgB,CAAC,EAAE,MAAM,kCAAkC;AAAA,EAC1F,UAAU,EAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,IAAI,CAAC;AAAA,EAC5D,QAAQ,EAAE,OAAO,EAAE,aAAa,iBAAiB,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,OAAO;AAAA,EACxE,iBAAiB,EAAE,OAAO,EAAE,aAAa,yBAAyB,CAAC,EAAE,IAAI,CAAC;AAC3E,CAAC,EAAE,SAAS,QAAQ;AAEpB,IAAM,iBAAiB,EAAE,OAAO;AAAA,EAC/B,KAAmB,sBAAQ;AAAA,EAC3B,UAAU,EAAE;AAAA,IACX,EAAE,OAAO,EAAE,aAAa,uBAAuB,CAAC,EAAE,SAAS,EAAE,MAAM,aAAa;AAAA,IAChF,EAAE,aAAa,kBAAkB;AAAA,EAClC;AAAA,EACA,OAAO,EAAE,OAAO,EAAE,aAAa,gBAAgB,CAAC,EAAE,MAAM,kCAAkC;AAAA,EAC1F,UAAU,EAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,SAAS;AAAA,EAChE,QAAQ,EAAE,OAAO,EAAE,aAAa,iBAAiB,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO;AAAA,EAC5E,iBAAiB,EAAE,OAAO,EAAE,aAAa,yBAAyB,CAAC,EAAE,SAAS;AAC/E,CAAC,EAAE,SAAS,QAAQ;AAKb,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,IAAMA,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAa;AAC/D;","names":["schemas"]}
+{"version":3,"sources":["Faucet.ts"],"sourcesContent":["import createType, { Flatten } from '@taqueria/protocol/Base';\nimport * as PublicKeyHash from '@taqueria/protocol/PublicKeyHash';\nimport { z } from 'zod';\n\nconst commonSchema = z.object({\n\tmnemonic: z.preprocess(\n\t\targ => typeof arg === 'string' ? arg.split(' ') : arg,\n\t\tz.array(\n\t\t\tz.string({ description: 'Faucet Mnemonic Word' }).min(1).regex(/^[a-z]{2,}$/),\n\t\t\t{ description: 'Faucet Mnemonic' },\n\t\t),\n\t),\n\temail: z.string({ description: 'Faucet E-mail' }).regex(/^([\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4})?$/).optional(),\n\tpassword: z.string({ description: 'Faucet Password' }).optional(),\n\tamount: z.string({ description: 'Faucet Amount' }).refine(\n\t\tval => val.length === 0 || /^\\d+$/.test(val),\n\t\t'Amount, if present, must be numeric',\n\t).optional(),\n\tactivation_code: z.string({ description: 'Faucet Activation Code' }).optional(),\n});\n\nexport const rawSchema = commonSchema.extend({\n\tpkh: z.string({ description: 'Faucet Public Key Hash' }).min(1),\n}).describe('Faucet');\n\nconst internalSchema = z.preprocess(\n\tinput => {\n\t\tconst defaults = {\n\t\t\tpkh: '',\n\t\t\tmnemonic: [],\n\t\t\temail: '',\n\t\t\tpassword: '',\n\t\t\tactivation_code: '',\n\t\t};\n\t\treturn typeof input === 'object'\n\t\t\t? { ...defaults, ...input }\n\t\t\t: defaults;\n\t},\n\tcommonSchema.extend({\n\t\tpkh: PublicKeyHash.schemas.schema,\n\t}),\n).describe('Faucet');\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 faucet configuration`,\n\tunknownErrMsg: 'Something went wrong trying to parse the faucet',\n});\n\nexport type Faucet = Flatten<z.infer<typeof generatedSchemas.schema>>;\nexport type t = Faucet;\nexport const { create, of, make } = factory;\n\nexport const schemas = {\n\t...generatedSchemas,\n\tschema: generatedSchemas.schema.transform(val => val as Faucet),\n};\n"],"mappings":";AAAA,OAAO,gBAA6B;AACpC,YAAY,mBAAmB;AAC/B,SAAS,SAAS;AAElB,IAAM,eAAe,EAAE,OAAO;AAAA,EAC7B,UAAU,EAAE;AAAA,IACX,SAAO,OAAO,QAAQ,WAAW,IAAI,MAAM,GAAG,IAAI;AAAA,IAClD,EAAE;AAAA,MACD,EAAE,OAAO,EAAE,aAAa,uBAAuB,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,aAAa;AAAA,MAC5E,EAAE,aAAa,kBAAkB;AAAA,IAClC;AAAA,EACD;AAAA,EACA,OAAO,EAAE,OAAO,EAAE,aAAa,gBAAgB,CAAC,EAAE,MAAM,qCAAqC,EAAE,SAAS;AAAA,EACxG,UAAU,EAAE,OAAO,EAAE,aAAa,kBAAkB,CAAC,EAAE,SAAS;AAAA,EAChE,QAAQ,EAAE,OAAO,EAAE,aAAa,gBAAgB,CAAC,EAAE;AAAA,IAClD,SAAO,IAAI,WAAW,KAAK,QAAQ,KAAK,GAAG;AAAA,IAC3C;AAAA,EACD,EAAE,SAAS;AAAA,EACX,iBAAiB,EAAE,OAAO,EAAE,aAAa,yBAAyB,CAAC,EAAE,SAAS;AAC/E,CAAC;AAEM,IAAM,YAAY,aAAa,OAAO;AAAA,EAC5C,KAAK,EAAE,OAAO,EAAE,aAAa,yBAAyB,CAAC,EAAE,IAAI,CAAC;AAC/D,CAAC,EAAE,SAAS,QAAQ;AAEpB,IAAM,iBAAiB,EAAE;AAAA,EACxB,WAAS;AACR,UAAM,WAAW;AAAA,MAChB,KAAK;AAAA,MACL,UAAU,CAAC;AAAA,MACX,OAAO;AAAA,MACP,UAAU;AAAA,MACV,iBAAiB;AAAA,IAClB;AACA,WAAO,OAAO,UAAU,WACrB,EAAE,GAAG,UAAU,GAAG,MAAM,IACxB;AAAA,EACJ;AAAA,EACA,aAAa,OAAO;AAAA,IACnB,KAAmB,sBAAQ;AAAA,EAC5B,CAAC;AACF,EAAE,SAAS,QAAQ;AAKZ,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,IAAMA,WAAU;AAAA,EACtB,GAAG;AAAA,EACH,QAAQ,iBAAiB,OAAO,UAAU,SAAO,GAAa;AAC/D;","names":["schemas"]}

package/HumanReadableIdentifier.d.ts

@@ -1,23 +1,18 @@
-import * as fluture from 'fluture';
-import { TaqError } from './TaqError.js';
 import { z } from 'zod';
-
-declare const rawSchema: z.ZodString;
-declare const internalSchema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
+export declare const rawSchema: z.ZodString;
+export declare const internalSchema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
     readonly __kind: any;
 }, any>;
-declare type HumanReadableIdentifier = z.infer<typeof internalSchema>;
-declare type t = HumanReadableIdentifier;
-declare const create: (input: string) => string & {
+export declare type HumanReadableIdentifier = z.infer<typeof internalSchema>;
+export declare type t = HumanReadableIdentifier;
+export declare const create: (input: string) => string & {
     readonly __kind: any;
-};
-declare const of: (input: unknown) => fluture.FutureInstance<TaqError, string & {
+}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
     readonly __kind: any;
-}>;
-declare const make: (input: string) => fluture.FutureInstance<TaqError, string & {
+}>, make: (input: string) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
     readonly __kind: any;
 }>;
-declare const schemas: {
+export declare const schemas: {
     schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
         readonly __kind: any;
     }, any>, string & {
@@ -26,5 +21,4 @@ declare const schemas: {
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
 };
-
-export { HumanReadableIdentifier, create, internalSchema, make, of, rawSchema, schemas, t };
+//# sourceMappingURL=HumanReadableIdentifier.d.ts.map

package/HumanReadableIdentifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HumanReadableIdentifier.d.ts","sourceRoot":"","sources":["HumanReadableIdentifier.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS,aAE4D,CAAC;AAWnF,eAAO,MAAM,cAAc;;OAA0B,CAAC;AAEtD,oBAAY,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACrE,oBAAY,CAAC,GAAG,uBAAuB,CAAC;AACxC,eAAO,MAAQ,MAAM;;GAAE,EAAE;;IAAE,IAAI;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;CAGnB,CAAC"}

package/InstalledPlugin.d.ts

@@ -1,8 +1,5 @@
-import * as fluture from 'fluture';
-import { TaqError } from './TaqError.js';
 import { z } from 'zod';
-
-declare const rawSchema: z.ZodObject<{
+export declare const rawSchema: z.ZodObject<{
     name: z.ZodString;
     type: z.ZodUnion<[z.ZodLiteral<"npm">, z.ZodLiteral<"binary">, z.ZodLiteral<"deno">]>;
 }, "strip", z.ZodTypeAny, {
@@ -12,7 +9,7 @@ declare const rawSchema: z.ZodObject<{
     type: "npm" | "binary" | "deno";
     name: string;
 }>;
-declare const generatedSchemas: {
+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>, {
@@ -21,18 +18,17 @@ declare const generatedSchemas: {
     } & {
         readonly __kind: any;
     }, any>;
-};
-declare const factory: {
+}, factory: {
     make: (input: {
         type: "npm" | "binary" | "deno";
         name: string;
-    }) => fluture.FutureInstance<TaqError, {
+    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
         type: "npm" | "binary" | "deno";
         name: string;
     } & {
         readonly __kind: any;
     }>;
-    of: (input: unknown) => fluture.FutureInstance<TaqError, {
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
         type: "npm" | "binary" | "deno";
         name: string;
     } & {
@@ -54,9 +50,9 @@ declare const factory: {
         readonly __kind: any;
     };
 };
-declare type InstalledPlugin = z.infer<typeof generatedSchemas.schema>;
-declare type t = InstalledPlugin;
-declare const create: (input: {
+export declare type InstalledPlugin = z.infer<typeof generatedSchemas.schema>;
+export declare type t = InstalledPlugin;
+export declare const create: (input: {
     type: "npm" | "binary" | "deno";
     name: string;
 }) => {
@@ -64,23 +60,21 @@ declare const create: (input: {
     name: string;
 } & {
     readonly __kind: any;
-};
-declare const of: (input: unknown) => fluture.FutureInstance<TaqError, {
+}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
     type: "npm" | "binary" | "deno";
     name: string;
 } & {
     readonly __kind: any;
-}>;
-declare const make: (input: {
+}>, make: (input: {
     type: "npm" | "binary" | "deno";
     name: string;
-}) => fluture.FutureInstance<TaqError, {
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
     type: "npm" | "binary" | "deno";
     name: string;
 } & {
     readonly __kind: any;
 }>;
-declare const schemas: {
+export declare const schemas: {
     schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
         type: "npm" | "binary" | "deno";
         name: string;
@@ -95,5 +89,4 @@ declare const schemas: {
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
 };
-
-export { InstalledPlugin, create, factory, generatedSchemas, make, of, rawSchema, schemas, t };
+//# sourceMappingURL=InstalledPlugin.d.ts.map

package/InstalledPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstalledPlugin.d.ts","sourceRoot":"","sources":["InstalledPlugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;EAMQ,CAAC;AAI/B,eAAO,MAAiB,gBAAgB;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/C,CAAC;AAEH,oBAAY,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AACtE,oBAAY,CAAC,GAAG,eAAe,CAAC;AAEhC,eAAO,MAAQ,MAAM;;;;;;;;GAAE,EAAE;;;;;IAAE,IAAI;;;;;;;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;CAGnB,CAAC"}