@taqueria/protocol 0.18.0 → 0.19.2

package/Alias.d.ts

@@ -1,9 +1,6 @@
-import * as fluture from 'fluture';
-import { TaqError } from './TaqError.js';
 import { z } from 'zod';
-
-declare const rawSchema: z.ZodUnion<[z.ZodString, z.ZodString]>;
-declare const internalSchema: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
+export declare const rawSchema: z.ZodUnion<[z.ZodString, z.ZodString]>;
+export declare const internalSchema: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
     readonly __kind: any;
 }, any>, string & {
     readonly __kind: any;
@@ -12,28 +9,26 @@ declare const internalSchema: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodType<an
 }, any>, string & {
     readonly __kind: any;
 }, any>]>;
-declare type Alias = z.infer<typeof internalSchema>;
-declare type t = Alias;
-declare const create: (input: string | (string & {
+export declare type Alias = z.infer<typeof internalSchema>;
+export declare type t = Alias;
+export declare const create: (input: string | (string & {
     readonly __kind: any;
 })) => string & {
     readonly __kind: any;
 } & {
     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;
 } & {
     readonly __kind: any;
-}>;
-declare const make: (input: string & {
+}>, make: (input: string & {
     readonly __kind: any;
-}) => fluture.FutureInstance<TaqError, string & {
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
     readonly __kind: any;
 } & {
     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;
     } & {
@@ -44,5 +39,4 @@ declare const schemas: {
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
 };
-
-export { Alias, create, internalSchema, make, of, rawSchema, schemas, t };
+//# sourceMappingURL=Alias.d.ts.map

package/Alias.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Alias.d.ts","sourceRoot":"","sources":["Alias.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS,wCAIO,CAAC;AAE9B,eAAO,MAAM,cAAc;;;;;;;;SAIE,CAAC;AAa9B,oBAAY,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEnD,oBAAY,CAAC,GAAG,KAAK,CAAC;AAEtB,eAAO,MAAQ,MAAM;;;;;;GAAE,EAAE;;;;IAAE,IAAI;;;;;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;;;CAGnB,CAAC"}

package/Base.d.ts

@@ -1,7 +1,5 @@
-import * as _taqueria_protocol_TaqError from '@taqueria/protocol/TaqError';
 import { FutureInstance } from 'fluture';
 import { z, ZodSchema } from 'zod';
-
 declare type ErrMsg = string | ((value: unknown) => string);
 interface CreateSchemaParams {
     rawSchema: ZodSchema;
@@ -13,17 +11,17 @@ interface CreateTypeParams extends CreateSchemaParams {
     parseErrMsg: ErrMsg;
     unknownErrMsg: ErrMsg;
 }
-declare type Flatten<T> = {
+export declare type Flatten<T> = {
     [k in keyof T]: T[k];
 };
-declare const createSchema: <I>(params: CreateSchemaParams) => {
+export declare const createSchema: <I>(params: CreateSchemaParams) => {
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
     schema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, I & {
         readonly __kind: any;
     }, any>;
 };
-declare const createType: <R, I>(params: CreateTypeParams) => {
+export declare const createType: <R, I>(params: CreateTypeParams) => {
     schemas: {
         rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
         internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
@@ -32,10 +30,10 @@ declare const createType: <R, I>(params: CreateTypeParams) => {
         }, any>;
     };
     factory: {
-        make: (input: I) => FutureInstance<_taqueria_protocol_TaqError.TaqError, I & {
+        make: (input: I) => FutureInstance<import("@taqueria/protocol/TaqError").TaqError, I & {
             readonly __kind: any;
         }>;
-        of: (input: unknown) => FutureInstance<_taqueria_protocol_TaqError.TaqError, I & {
+        of: (input: unknown) => FutureInstance<import("@taqueria/protocol/TaqError").TaqError, I & {
             readonly __kind: any;
         }>;
         create: (input: R | I) => I & {
@@ -46,5 +44,5 @@ declare const createType: <R, I>(params: CreateTypeParams) => {
         };
     };
 };
-
-export { Flatten, createSchema, createType, createType as default };
+export default createType;
+//# sourceMappingURL=Base.d.ts.map

package/Base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Base.d.ts","sourceRoot":"","sources":["Base.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAW,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,CAAC,EAAY,SAAS,EAAE,MAAM,KAAK,CAAC;AAI7C,aAAK,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC,CAAC;AAEpD,UAAU,kBAAkB;IAC3B,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,CAAC,EAAE,SAAS,CAAC;IAC3B,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAC1C,YAAY,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,UAAU,gBAAiB,SAAQ,kBAAkB;IACpD,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACtB;AACD,oBAAY,OAAO,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAElD,eAAO,MAAM,YAAY,cAAe,kBAAkB;;;;;;CA6BzD,CAAC;AASF,eAAO,MAAM,UAAU,iBAAkB,gBAAgB;;;;;;;;;;;;oBAM7B,OAAO;;;;;;sBAwBb,OAAO;;;;CAa5B,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/Command.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 Command = z.infer<typeof internalSchema>;
-declare type t = Command;
-declare const create: (input: string) => string & {
+export declare type Command = z.infer<typeof internalSchema>;
+export declare type t = Command;
+export declare const create: (input: string) => 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 of: (input: unknown) => fluture.FutureInstance<TaqError, string & {
+}>, of: (input: unknown) => 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 { Command, create, internalSchema, make, of, rawSchema, schemas, t };
+//# sourceMappingURL=Command.d.ts.map

package/Command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Command.d.ts","sourceRoot":"","sources":["Command.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS,aAGwF,CAAC;AAW/G,eAAO,MAAM,cAAc;;OAA0B,CAAC;AAEtD,oBAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACrD,oBAAY,CAAC,GAAG,OAAO,CAAC;AACxB,eAAO,MAAQ,MAAM;;GAAE,IAAI;;IAAE,EAAE;;EAAY,CAAC;AAC5C,eAAO,MAAM,OAAO;;;;;;;;CAGnB,CAAC"}

package/Config.d.ts

@@ -1,9 +1,6 @@
-import * as fluture from 'fluture';
-import { TaqError } from './TaqError.js';
 import { Flatten } from '@taqueria/protocol/Base';
 import { z } from 'zod';
-
-declare const pluginsRawSchema: z.ZodEffects<z.ZodArray<z.ZodObject<{
+export declare const pluginsRawSchema: z.ZodEffects<z.ZodArray<z.ZodObject<{
     name: z.ZodString;
     type: z.ZodUnion<[z.ZodLiteral<"npm">, z.ZodLiteral<"binary">, z.ZodLiteral<"deno">]>;
 }, "strip", z.ZodTypeAny, {
@@ -16,7 +13,7 @@ declare const pluginsRawSchema: z.ZodEffects<z.ZodArray<z.ZodObject<{
     type: "npm" | "binary" | "deno";
     name: string;
 }[], unknown>;
-declare const pluginsInternalSchema: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
+export declare const pluginsInternalSchema: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
     type: "npm" | "binary" | "deno";
     name: string;
 } & {
@@ -32,7 +29,7 @@ declare const pluginsInternalSchema: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodE
 } & {
     readonly __kind: any;
 })[], unknown>;
-declare const internalSchema: z.ZodObject<z.extendShape<{
+export declare const internalSchema: z.ZodObject<z.extendShape<{
     language: z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"en">, z.ZodLiteral<"fr">]>>, "en" | "fr" | undefined, unknown>;
     plugins: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
         type: "npm" | "binary" | "deno";
@@ -321,7 +318,7 @@ declare const internalSchema: z.ZodObject<z.extendShape<{
     environment?: Record<string, any> | undefined;
     metadata?: any;
 }>;
-declare const rawSchema: z.ZodObject<z.extendShape<{
+export declare const rawSchema: z.ZodObject<z.extendShape<{
     language: z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"en">, z.ZodLiteral<"fr">]>>, "en" | "fr" | undefined, unknown>;
     plugins: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
         type: "npm" | "binary" | "deno";
@@ -641,7 +638,7 @@ declare const rawSchema: z.ZodObject<z.extendShape<{
         homepage?: string | undefined;
     } | undefined;
 }>;
-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>, {
@@ -737,8 +734,7 @@ declare const generatedSchemas: {
     } & {
         readonly __kind: any;
     }, any>;
-};
-declare const factory: {
+}, factory: {
     make: (input: {
         language?: "en" | "fr" | undefined;
         plugins?: ({
@@ -829,7 +825,7 @@ declare const factory: {
         accounts: Record<string, string | number>;
         contractsDir: string;
         artifactsDir: string;
-    }) => fluture.FutureInstance<TaqError, {
+    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
         language?: "en" | "fr" | undefined;
         plugins?: ({
             type: "npm" | "binary" | "deno";
@@ -922,7 +918,7 @@ declare const factory: {
     } & {
         readonly __kind: any;
     }>;
-    of: (input: unknown) => fluture.FutureInstance<TaqError, {
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
         language?: "en" | "fr" | undefined;
         plugins?: ({
             type: "npm" | "binary" | "deno";
@@ -1350,7 +1346,7 @@ declare const factory: {
         readonly __kind: any;
     };
 };
-declare const create: (input: {
+export declare const create: (input: {
     language?: "en" | "fr" | undefined;
     plugins?: ({
         type: "npm" | "binary" | "deno";
@@ -1590,8 +1586,7 @@ declare const create: (input: {
     artifactsDir: string;
 } & {
     readonly __kind: any;
-};
-declare const of: (input: unknown) => fluture.FutureInstance<TaqError, {
+}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
     language?: "en" | "fr" | undefined;
     plugins?: ({
         type: "npm" | "binary" | "deno";
@@ -1683,8 +1678,7 @@ declare const of: (input: unknown) => fluture.FutureInstance<TaqError, {
     artifactsDir: string;
 } & {
     readonly __kind: any;
-}>;
-declare const make: (input: {
+}>, make: (input: {
     language?: "en" | "fr" | undefined;
     plugins?: ({
         type: "npm" | "binary" | "deno";
@@ -1774,7 +1768,7 @@ declare const make: (input: {
     accounts: Record<string, string | number>;
     contractsDir: string;
     artifactsDir: string;
-}) => fluture.FutureInstance<TaqError, {
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
     language?: "en" | "fr" | undefined;
     plugins?: ({
         type: "npm" | "binary" | "deno";
@@ -1867,9 +1861,9 @@ declare const make: (input: {
 } & {
     readonly __kind: any;
 }>;
-declare type Config = z.infer<typeof generatedSchemas.schema>;
-declare type t = Config;
-declare const schemas: {
+export declare type Config = z.infer<typeof generatedSchemas.schema>;
+export declare type t = Config;
+export declare const schemas: {
     schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
         language?: "en" | "fr" | undefined;
         plugins?: ({
@@ -2058,5 +2052,4 @@ declare const schemas: {
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
 };
-
-export { Config, create, factory, generatedSchemas, internalSchema, make, of, pluginsInternalSchema, pluginsRawSchema, rawSchema, schemas, t };
+//# sourceMappingURL=Config.d.ts.map

package/Config.d.ts.map

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

package/Contract.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<{
     sourceFile: z.ZodString;
     hash: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -12,7 +9,7 @@ declare const rawSchema: z.ZodObject<{
     sourceFile: string;
     hash: string;
 }>;
-declare const internalSchema: z.ZodObject<{
+export declare const internalSchema: z.ZodObject<{
     sourceFile: z.ZodString;
     hash: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
         readonly __kind: any;
@@ -28,9 +25,9 @@ declare const internalSchema: z.ZodObject<{
     hash?: any;
     sourceFile: string;
 }>;
-declare type Contract = z.infer<typeof internalSchema>;
-declare type t = Contract;
-declare const create: (input: {
+export declare type Contract = z.infer<typeof internalSchema>;
+export declare type t = Contract;
+export declare const create: (input: {
     sourceFile: string;
     hash: string;
 } | {
@@ -45,21 +42,19 @@ declare const create: (input: {
     };
 } & {
     readonly __kind: any;
-};
-declare const of: (input: unknown) => fluture.FutureInstance<TaqError, {
+}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
     sourceFile: string;
     hash: string & {
         readonly __kind: any;
     };
 } & {
     readonly __kind: any;
-}>;
-declare const make: (input: {
+}>, make: (input: {
     sourceFile: string;
     hash: string & {
         readonly __kind: any;
     };
-}) => fluture.FutureInstance<TaqError, {
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
     sourceFile: string;
     hash: string & {
         readonly __kind: any;
@@ -67,7 +62,7 @@ declare const make: (input: {
 } & {
     readonly __kind: any;
 }>;
-declare const schemas: {
+export declare const schemas: {
     schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
         sourceFile: string;
         hash: string & {
@@ -84,5 +79,4 @@ declare const schemas: {
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
 };
-
-export { Contract, create, internalSchema, make, of, rawSchema, schemas, t };
+//# sourceMappingURL=Contract.d.ts.map

package/Contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contract.d.ts","sourceRoot":"","sources":["Contract.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;EAIpB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EAGzB,CAAC;AAYH,oBAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,oBAAY,CAAC,GAAG,QAAQ,CAAC;AAEzB,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;GAAE,EAAE;;;;;;;IAAE,IAAI;;;;;;;;;;;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;CAGnB,CAAC"}

package/Crypto.d.ts

@@ -1,5 +1,4 @@
-declare class Crypto {
+export declare class Crypto {
     subtle: SubtleCrypto;
 }
-
-export { Crypto };
+//# sourceMappingURL=Crypto.d.ts.map

package/Crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Crypto.d.ts","sourceRoot":"","sources":["Crypto.ts"],"names":[],"mappings":"AAAA,qBAAa,MAAM;IAClB,MAAM,EAAE,YAAY,CAAiB;CACrC"}

package/EconomicalProtocolHash.d.ts

@@ -1,20 +1,16 @@
-import * as fluture from 'fluture';
-import { TaqError } from './TaqError.js';
 import { z } from 'zod';
-
-declare const rawSchema: z.ZodEffects<z.ZodString, string, string>;
-declare const generatedSchemas: {
+export declare const rawSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const generatedSchemas: {
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
     schema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
         readonly __kind: any;
     }, any>;
-};
-declare const factory: {
-    make: (input: string) => fluture.FutureInstance<TaqError, string & {
+}, factory: {
+    make: (input: string) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
         readonly __kind: any;
     }>;
-    of: (input: unknown) => fluture.FutureInstance<TaqError, string & {
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, string & {
         readonly __kind: any;
     }>;
     create: (input: string) => string & {
@@ -24,18 +20,16 @@ declare const factory: {
         readonly __kind: any;
     };
 };
-declare type EconomicalPrototypeHash = z.infer<typeof generatedSchemas.schema>;
-declare type t = EconomicalPrototypeHash;
-declare const create: (input: string) => string & {
+export declare type EconomicalPrototypeHash = z.infer<typeof generatedSchemas.schema>;
+export declare type t = EconomicalPrototypeHash;
+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 & {
@@ -44,5 +38,4 @@ declare const schemas: {
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
 };
-
-export { EconomicalPrototypeHash, create, factory, generatedSchemas, make, of, rawSchema, schemas, t };
+//# sourceMappingURL=EconomicalProtocolHash.d.ts.map

package/EconomicalProtocolHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EconomicalProtocolHash.d.ts","sourceRoot":"","sources":["EconomicalProtocolHash.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS,2CAKpB,CAAC;AAIH,eAAO,MAAiB,gBAAgB;;;;;;GAAE,OAAO;;;;;;;;;;;;;CAI/C,CAAC;AAEH,oBAAY,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAC9E,oBAAY,CAAC,GAAG,uBAAuB,CAAC;AAExC,eAAO,MAAQ,MAAM;;GAAE,EAAE;;IAAE,IAAI;;EAAY,CAAC;AAC5C,eAAO,MAAM,OAAO;;;;;;;;CAGnB,CAAC"}

package/Environment.d.ts

@@ -1,9 +1,6 @@
-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<{
     networks: z.ZodArray<z.ZodString, "many">;
     sandboxes: z.ZodArray<z.ZodString, "many">;
     storage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
@@ -19,7 +16,7 @@ declare const rawSchema: z.ZodObject<{
     networks: string[];
     sandboxes: 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>, {
@@ -30,14 +27,13 @@ declare const generatedSchemas: {
     } & {
         readonly __kind: any;
     }, any>;
-};
-declare const factory: {
+}, factory: {
     make: (input: {
         storage?: Record<string, any> | undefined;
         aliases?: Record<string, any> | undefined;
         networks: string[];
         sandboxes: string[];
-    }) => fluture.FutureInstance<TaqError, {
+    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
         storage?: Record<string, any> | undefined;
         aliases?: Record<string, any> | undefined;
         networks: string[];
@@ -45,7 +41,7 @@ declare const factory: {
     } & {
         readonly __kind: any;
     }>;
-    of: (input: unknown) => fluture.FutureInstance<TaqError, {
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
         storage?: Record<string, any> | undefined;
         aliases?: Record<string, any> | undefined;
         networks: string[];
@@ -75,9 +71,9 @@ declare const factory: {
         readonly __kind: any;
     };
 };
-declare type Environment = Flatten<z.infer<typeof generatedSchemas.schema>>;
-declare type t = Environment;
-declare const create: (input: {
+export declare type Environment = Flatten<z.infer<typeof generatedSchemas.schema>>;
+export declare type t = Environment;
+export declare const create: (input: {
     storage?: Record<string, any> | undefined;
     aliases?: Record<string, any> | undefined;
     networks: string[];
@@ -89,29 +85,26 @@ declare const create: (input: {
     sandboxes: string[];
 } & {
     readonly __kind: any;
-};
-declare const make: (input: {
+}, make: (input: {
     storage?: Record<string, any> | undefined;
     aliases?: Record<string, any> | undefined;
     networks: string[];
     sandboxes: string[];
-}) => fluture.FutureInstance<TaqError, {
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
     storage?: Record<string, any> | undefined;
     aliases?: Record<string, any> | undefined;
     networks: string[];
     sandboxes: string[];
 } & {
     readonly __kind: any;
-}>;
-declare const of: (input: unknown) => fluture.FutureInstance<TaqError, {
+}>, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
     storage?: Record<string, any> | undefined;
     aliases?: Record<string, any> | undefined;
     networks: string[];
     sandboxes: string[];
 } & {
     readonly __kind: any;
-}>;
-declare const from: (input: unknown) => {
+}>, from: (input: unknown) => {
     storage?: Record<string, any> | undefined;
     aliases?: Record<string, any> | undefined;
     networks: string[];
@@ -119,7 +112,7 @@ declare const from: (input: unknown) => {
 } & {
     readonly __kind: any;
 };
-declare const schemas: {
+export declare const schemas: {
     schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
         storage?: Record<string, any> | undefined;
         aliases?: Record<string, any> | undefined;
@@ -138,5 +131,4 @@ declare const schemas: {
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
 };
-
-export { Environment, create, factory, from, generatedSchemas, make, of, rawSchema, schemas, t };
+//# sourceMappingURL=Environment.d.ts.map

package/Environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Environment.d.ts","sourceRoot":"","sources":["Environment.ts"],"names":[],"mappings":"AAAA,OAAmB,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;EAkBW,CAAC;AAIlC,eAAO,MAAiB,gBAAgB;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/C,CAAC;AAEH,oBAAY,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;AAC3E,oBAAY,CAAC,GAAG,WAAW,CAAC;AAE5B,eAAO,MAAQ,MAAM;;;;;;;;;;;;GAAE,IAAI;;;;;;;;;;;;IAAE,EAAE;;;;;;;IAAE,IAAI;;;;;;;CAAY,CAAC;AAElD,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;CAGnB,CAAC"}