@taqueria/protocol 0.18.0 → 0.19.3

package/ParsedTemplate.d.ts

@@ -1,9 +1,5 @@
-import * as fluture from 'fluture';
-import { TaqError } from './TaqError.js';
-import * as _taqueria_protocol_Base from '@taqueria/protocol/Base';
 import { z } from 'zod';
-
-declare const rawSchema: z.ZodObject<z.extendShape<{
+export declare const rawSchema: z.ZodObject<z.extendShape<{
     template: z.ZodString;
     command: z.ZodString;
     description: z.ZodString;
@@ -78,7 +74,7 @@ declare const rawSchema: z.ZodObject<z.extendShape<{
         yes?: boolean | undefined;
         quickstart?: string | undefined;
         pluginName?: string | undefined;
-        config: _taqueria_protocol_Base.Flatten<{
+        config: import("@taqueria/protocol/Base").Flatten<{
             language?: "en" | "fr" | undefined;
             contracts?: Record<string, {
                 sourceFile: string;
@@ -86,7 +82,7 @@ declare const rawSchema: z.ZodObject<z.extendShape<{
                     readonly __kind: any;
                 };
             }> | undefined;
-            network?: Record<string, string | _taqueria_protocol_Base.Flatten<{
+            network?: Record<string, import("@taqueria/protocol/Base").Flatten<{
                 label: string & {
                     readonly __kind: any;
                 };
@@ -96,22 +92,22 @@ declare const rawSchema: z.ZodObject<z.extendShape<{
                 protocol: string & {
                     readonly __kind: any;
                 };
-                faucet: _taqueria_protocol_Base.Flatten<{
+                faucet: import("@taqueria/protocol/Base").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;
                 }>;
             } & {
                 readonly __kind: any;
             }>> | undefined;
-            sandbox?: Record<string, string | ({
+            sandbox?: Record<string, {
                 attributes?: Record<string, string | number | boolean> | undefined;
                 plugin?: (string & {
                     readonly __kind: any;
@@ -141,8 +137,8 @@ declare const rawSchema: z.ZodObject<z.extendShape<{
                 };
             } & {
                 readonly __kind: any;
-            })> | undefined;
-            environment?: Record<string, string | _taqueria_protocol_Base.Flatten<{
+            }> | undefined;
+            environment?: Record<string, string | import("@taqueria/protocol/Base").Flatten<{
                 storage?: Record<string, any> | undefined;
                 aliases?: Record<string, any> | undefined;
                 networks: string[];
@@ -203,7 +199,7 @@ declare const rawSchema: z.ZodObject<z.extendShape<{
         yes?: boolean | undefined;
         quickstart?: string | undefined;
         pluginName?: string | undefined;
-        config: _taqueria_protocol_Base.Flatten<{
+        config: import("@taqueria/protocol/Base").Flatten<{
             language?: "en" | "fr" | undefined;
             contracts?: Record<string, {
                 sourceFile: string;
@@ -211,7 +207,7 @@ declare const rawSchema: z.ZodObject<z.extendShape<{
                     readonly __kind: any;
                 };
             }> | undefined;
-            network?: Record<string, string | _taqueria_protocol_Base.Flatten<{
+            network?: Record<string, import("@taqueria/protocol/Base").Flatten<{
                 label: string & {
                     readonly __kind: any;
                 };
@@ -221,22 +217,22 @@ declare const rawSchema: z.ZodObject<z.extendShape<{
                 protocol: string & {
                     readonly __kind: any;
                 };
-                faucet: _taqueria_protocol_Base.Flatten<{
+                faucet: import("@taqueria/protocol/Base").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;
                 }>;
             } & {
                 readonly __kind: any;
             }>> | undefined;
-            sandbox?: Record<string, string | ({
+            sandbox?: Record<string, {
                 attributes?: Record<string, string | number | boolean> | undefined;
                 plugin?: (string & {
                     readonly __kind: any;
@@ -266,8 +262,8 @@ declare const rawSchema: z.ZodObject<z.extendShape<{
                 };
             } & {
                 readonly __kind: any;
-            })> | undefined;
-            environment?: Record<string, string | _taqueria_protocol_Base.Flatten<{
+            }> | undefined;
+            environment?: Record<string, string | import("@taqueria/protocol/Base").Flatten<{
                 storage?: Record<string, any> | undefined;
                 aliases?: Record<string, any> | undefined;
                 networks: string[];
@@ -375,11 +371,11 @@ declare const rawSchema: z.ZodObject<z.extendShape<{
     command: string;
     handler: 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>, {
-        options?: _taqueria_protocol_Base.Flatten<{
+        options?: import("@taqueria/protocol/Base").Flatten<{
             boolean?: boolean | undefined;
             type?: "string" | "number" | "boolean" | undefined;
             shortFlag?: (string & {
@@ -421,10 +417,9 @@ declare const generatedSchemas: {
     } & {
         readonly __kind: any;
     }, any>;
-};
-declare const factory: {
+}, factory: {
     make: (input: {
-        options?: _taqueria_protocol_Base.Flatten<{
+        options?: import("@taqueria/protocol/Base").Flatten<{
             boolean?: boolean | undefined;
             type?: "string" | "number" | "boolean" | undefined;
             shortFlag?: (string & {
@@ -463,8 +458,8 @@ declare const factory: {
         encoding: ("none" | "json" | "application/json" | undefined) & {
             readonly __kind: any;
         };
-    }) => fluture.FutureInstance<TaqError, {
-        options?: _taqueria_protocol_Base.Flatten<{
+    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        options?: import("@taqueria/protocol/Base").Flatten<{
             boolean?: boolean | undefined;
             type?: "string" | "number" | "boolean" | undefined;
             shortFlag?: (string & {
@@ -506,8 +501,8 @@ declare const factory: {
     } & {
         readonly __kind: any;
     }>;
-    of: (input: unknown) => fluture.FutureInstance<TaqError, {
-        options?: _taqueria_protocol_Base.Flatten<{
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+        options?: import("@taqueria/protocol/Base").Flatten<{
             boolean?: boolean | undefined;
             type?: "string" | "number" | "boolean" | undefined;
             shortFlag?: (string & {
@@ -550,7 +545,7 @@ declare const factory: {
         readonly __kind: any;
     }>;
     create: (input: {
-        options?: _taqueria_protocol_Base.Flatten<{
+        options?: import("@taqueria/protocol/Base").Flatten<{
             boolean?: boolean | undefined;
             type?: "string" | "number" | "boolean" | undefined;
             shortFlag?: (string & {
@@ -616,7 +611,7 @@ declare const factory: {
             readonly __kind: any;
         };
     }) => {
-        options?: _taqueria_protocol_Base.Flatten<{
+        options?: import("@taqueria/protocol/Base").Flatten<{
             boolean?: boolean | undefined;
             type?: "string" | "number" | "boolean" | undefined;
             shortFlag?: (string & {
@@ -659,7 +654,7 @@ declare const factory: {
         readonly __kind: any;
     };
     from: (input: unknown) => {
-        options?: _taqueria_protocol_Base.Flatten<{
+        options?: import("@taqueria/protocol/Base").Flatten<{
             boolean?: boolean | undefined;
             type?: "string" | "number" | "boolean" | undefined;
             shortFlag?: (string & {
@@ -702,10 +697,10 @@ declare const factory: {
         readonly __kind: any;
     };
 };
-declare type ParsedTemplate = z.infer<typeof generatedSchemas.schema>;
-declare type t = ParsedTemplate;
-declare const create: (input: {
-    options?: _taqueria_protocol_Base.Flatten<{
+export declare type ParsedTemplate = z.infer<typeof generatedSchemas.schema>;
+export declare type t = ParsedTemplate;
+export declare const create: (input: {
+    options?: import("@taqueria/protocol/Base").Flatten<{
         boolean?: boolean | undefined;
         type?: "string" | "number" | "boolean" | undefined;
         shortFlag?: (string & {
@@ -771,7 +766,7 @@ declare const create: (input: {
         readonly __kind: any;
     };
 }) => {
-    options?: _taqueria_protocol_Base.Flatten<{
+    options?: import("@taqueria/protocol/Base").Flatten<{
         boolean?: boolean | undefined;
         type?: "string" | "number" | "boolean" | undefined;
         shortFlag?: (string & {
@@ -812,9 +807,8 @@ declare const create: (input: {
     };
 } & {
     readonly __kind: any;
-};
-declare const make: (input: {
-    options?: _taqueria_protocol_Base.Flatten<{
+}, make: (input: {
+    options?: import("@taqueria/protocol/Base").Flatten<{
         boolean?: boolean | undefined;
         type?: "string" | "number" | "boolean" | undefined;
         shortFlag?: (string & {
@@ -853,8 +847,8 @@ declare const make: (input: {
     encoding: ("none" | "json" | "application/json" | undefined) & {
         readonly __kind: any;
     };
-}) => fluture.FutureInstance<TaqError, {
-    options?: _taqueria_protocol_Base.Flatten<{
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+    options?: import("@taqueria/protocol/Base").Flatten<{
         boolean?: boolean | undefined;
         type?: "string" | "number" | "boolean" | undefined;
         shortFlag?: (string & {
@@ -895,9 +889,8 @@ declare const make: (input: {
     };
 } & {
     readonly __kind: any;
-}>;
-declare const of: (input: unknown) => fluture.FutureInstance<TaqError, {
-    options?: _taqueria_protocol_Base.Flatten<{
+}>, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
+    options?: import("@taqueria/protocol/Base").Flatten<{
         boolean?: boolean | undefined;
         type?: "string" | "number" | "boolean" | undefined;
         shortFlag?: (string & {
@@ -939,9 +932,9 @@ declare const of: (input: unknown) => fluture.FutureInstance<TaqError, {
 } & {
     readonly __kind: any;
 }>;
-declare const schemas: {
+export declare const schemas: {
     schema: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
-        options?: _taqueria_protocol_Base.Flatten<{
+        options?: import("@taqueria/protocol/Base").Flatten<{
             boolean?: boolean | undefined;
             type?: "string" | "number" | "boolean" | undefined;
             shortFlag?: (string & {
@@ -983,7 +976,7 @@ declare const schemas: {
     } & {
         readonly __kind: any;
     }, any>, {
-        options?: _taqueria_protocol_Base.Flatten<{
+        options?: import("@taqueria/protocol/Base").Flatten<{
             boolean?: boolean | undefined;
             type?: "string" | "number" | "boolean" | undefined;
             shortFlag?: (string & {
@@ -1028,5 +1021,4 @@ declare const schemas: {
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
 };
-
-export { ParsedTemplate, create, factory, generatedSchemas, make, of, rawSchema, schemas, t };
+//# sourceMappingURL=ParsedTemplate.d.ts.map

package/ParsedTemplate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParsedTemplate.d.ts","sourceRoot":"","sources":["ParsedTemplate.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMM,CAAC;AAK7B,eAAO,MAAiB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK/C,CAAC;AAEH,oBAAY,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;AACrE,oBAAY,CAAC,GAAG,cAAc,CAAC;AAE/B,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC"}

package/PersistentState.d.ts

@@ -1,7 +1,4 @@
-import * as fluture from 'fluture';
-import { TaqError } from './TaqError.js';
 import { z } from 'zod';
-
 declare const internalOpSchema: z.ZodObject<{
     hash: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
         readonly __kind: any;
@@ -55,9 +52,9 @@ declare const internalTaskSchema: z.ZodObject<{
     task?: any;
     plugin: string;
 }>;
-declare type PersistedTask = z.infer<typeof internalTaskSchema>;
-declare type PersistedOperation = z.infer<typeof internalOpSchema>;
-declare const rawSchema: z.ZodObject<{
+export declare type PersistedTask = z.infer<typeof internalTaskSchema>;
+export declare type PersistedOperation = z.infer<typeof internalOpSchema>;
+export declare const rawSchema: z.ZodObject<{
     operations: z.ZodRecord<z.ZodString, z.ZodObject<{
         hash: z.ZodString;
         time: z.ZodNumber;
@@ -112,7 +109,7 @@ declare const rawSchema: z.ZodObject<{
         time: number;
     }>;
 }>;
-declare const internalSchema: z.ZodEffects<z.ZodObject<{
+export declare const internalSchema: z.ZodEffects<z.ZodObject<{
     operations: z.ZodRecord<z.ZodString, z.ZodObject<{
         hash: z.ZodEffects<z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, string & {
             readonly __kind: any;
@@ -231,7 +228,7 @@ declare const internalSchema: z.ZodEffects<z.ZodObject<{
         plugin: 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>, {
@@ -257,8 +254,7 @@ declare const generatedSchemas: {
     } & {
         readonly __kind: any;
     }, any>;
-};
-declare const factory: {
+}, factory: {
     make: (input: {
         operations: Record<string, {
             output?: unknown;
@@ -279,7 +275,7 @@ declare const factory: {
                 readonly __kind: any;
             };
         }>;
-    }) => fluture.FutureInstance<TaqError, {
+    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
         operations: Record<string, {
             output?: unknown;
             hash: string & {
@@ -302,7 +298,7 @@ declare const factory: {
     } & {
         readonly __kind: any;
     }>;
-    of: (input: unknown) => fluture.FutureInstance<TaqError, {
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
         operations: Record<string, {
             output?: unknown;
             hash: string & {
@@ -404,10 +400,10 @@ declare const factory: {
         readonly __kind: any;
     };
 };
-declare type PersistentState = z.infer<typeof generatedSchemas.schema>;
-declare type t = PersistentState;
-declare type State = PersistentState;
-declare const create: (input: {
+export declare type PersistentState = z.infer<typeof generatedSchemas.schema>;
+export declare type t = PersistentState;
+export declare type State = PersistentState;
+export declare const create: (input: {
     operations: Record<string, {
         output?: unknown;
         hash: string;
@@ -461,8 +457,7 @@ declare const create: (input: {
     }>;
 } & {
     readonly __kind: any;
-};
-declare const of: (input: unknown) => fluture.FutureInstance<TaqError, {
+}, of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
     operations: Record<string, {
         output?: unknown;
         hash: string & {
@@ -484,8 +479,7 @@ declare const of: (input: unknown) => fluture.FutureInstance<TaqError, {
     }>;
 } & {
     readonly __kind: any;
-}>;
-declare const make: (input: {
+}>, make: (input: {
     operations: Record<string, {
         output?: unknown;
         hash: string & {
@@ -505,7 +499,7 @@ declare const make: (input: {
             readonly __kind: any;
         };
     }>;
-}) => fluture.FutureInstance<TaqError, {
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
     operations: Record<string, {
         output?: unknown;
         hash: string & {
@@ -528,7 +522,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>, {
         operations: Record<string, {
             output?: unknown;
@@ -577,5 +571,5 @@ declare const schemas: {
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
 };
-
-export { PersistedOperation, PersistedTask, PersistentState, State, create, factory, generatedSchemas, internalSchema, make, of, rawSchema, schemas, t };
+export {};
+//# sourceMappingURL=PersistentState.d.ts.map

package/PersistentState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistentState.d.ts","sourceRoot":"","sources":["PersistentState.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;EAIpB,CAAC;AAEH,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtB,CAAC;AAEH,oBAAY,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,oBAAY,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAElE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMxB,CAAC;AAMJ,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;AAChC,oBAAY,KAAK,GAAG,eAAe,CAAC;AAEpC,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;IAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAY,CAAC;AAE5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGnB,CAAC"}

package/PluginActionName.d.ts

@@ -1,8 +1,7 @@
 import { z } from 'zod';
-
 declare const rawSchema: z.ZodUnion<[z.ZodLiteral<"checkRuntimeDependencies">, z.ZodLiteral<"installRuntimeDependencies">, z.ZodLiteral<"proxy">, z.ZodLiteral<"proxyTemplate">, z.ZodLiteral<"pluginInfo">]>;
-declare type PluginActionName = z.infer<typeof rawSchema>;
-declare type t = PluginActionName;
+export declare type PluginActionName = z.infer<typeof rawSchema>;
+export declare type t = PluginActionName;
 declare const pluginActionNotSupportedSchema: z.ZodObject<{
     status: z.ZodLiteral<"notSupported">;
     msg: z.ZodString;
@@ -13,11 +12,11 @@ declare const pluginActionNotSupportedSchema: z.ZodObject<{
     status: "notSupported";
     msg: string;
 }>;
-declare type PluginActionNotSupportedResponse = z.infer<typeof pluginActionNotSupportedSchema>;
-declare const schemas: {
+export declare type PluginActionNotSupportedResponse = z.infer<typeof pluginActionNotSupportedSchema>;
+export declare const schemas: {
     schema: z.ZodUnion<[z.ZodLiteral<"checkRuntimeDependencies">, z.ZodLiteral<"installRuntimeDependencies">, z.ZodLiteral<"proxy">, z.ZodLiteral<"proxyTemplate">, z.ZodLiteral<"pluginInfo">]>;
     internalSchema: z.ZodUnion<[z.ZodLiteral<"checkRuntimeDependencies">, z.ZodLiteral<"installRuntimeDependencies">, z.ZodLiteral<"proxy">, z.ZodLiteral<"proxyTemplate">, z.ZodLiteral<"pluginInfo">]>;
     rawSchema: z.ZodUnion<[z.ZodLiteral<"checkRuntimeDependencies">, z.ZodLiteral<"installRuntimeDependencies">, z.ZodLiteral<"proxy">, z.ZodLiteral<"proxyTemplate">, z.ZodLiteral<"pluginInfo">]>;
 };
-
-export { PluginActionName, PluginActionNotSupportedResponse, schemas, t };
+export {};
+//# sourceMappingURL=PluginActionName.d.ts.map

package/PluginActionName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginActionName.d.ts","sourceRoot":"","sources":["PluginActionName.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,SAAS,sLAMb,CAAC;AAIH,oBAAY,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AACzD,oBAAY,CAAC,GAAG,gBAAgB,CAAC;AAEjC,QAAA,MAAM,8BAA8B;;;;;;;;;EAGlC,CAAC;AAEH,oBAAY,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAE9F,eAAO,MAAM,OAAO;;;;CAInB,CAAC"}

package/PluginDependenciesResponse.d.ts

@@ -1,8 +1,5 @@
-import * as fluture from 'fluture';
-import { TaqError } from './TaqError.js';
 import { z } from 'zod';
-
-declare const schemas: {
+export declare const schemas: {
     rawSchema: z.ZodType<any, z.ZodTypeDef, any>;
     internalSchema: z.ZodType<any, z.ZodTypeDef, any>;
     schema: z.ZodEffects<z.ZodType<any, z.ZodTypeDef, any>, {
@@ -13,14 +10,13 @@ declare const schemas: {
     } & {
         readonly __kind: any;
     }, any>;
-};
-declare const factory: {
+}, factory: {
     make: (input: {
         path: string;
         name: string;
         version: string;
         kind: "required" | "optional";
-    }) => fluture.FutureInstance<TaqError, {
+    }) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
         path: string;
         name: string;
         version: string;
@@ -28,7 +24,7 @@ declare const factory: {
     } & {
         readonly __kind: any;
     }>;
-    of: (input: unknown) => fluture.FutureInstance<TaqError, {
+    of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
         path: string;
         name: string;
         version: string;
@@ -58,7 +54,7 @@ declare const factory: {
         readonly __kind: any;
     };
 };
-declare type RuntimeDependency = z.infer<typeof schemas.schema>;
+export declare type RuntimeDependency = z.infer<typeof schemas.schema>;
 declare const runtimeDependencyReport: z.ZodObject<z.extendShape<{
     name: z.ZodString;
     path: z.ZodString;
@@ -79,7 +75,7 @@ declare const runtimeDependencyReport: z.ZodObject<z.extendShape<{
     kind: "required" | "optional";
     met: boolean;
 }>;
-declare type RuntimeDependencyReport = z.infer<typeof runtimeDependencyReport>;
+export declare type RuntimeDependencyReport = z.infer<typeof runtimeDependencyReport>;
 declare const dependenciesResponseSchema: z.ZodObject<{
     report: z.ZodArray<z.ZodObject<z.extendShape<{
         name: z.ZodString;
@@ -118,30 +114,28 @@ declare const dependenciesResponseSchema: z.ZodObject<{
         met: boolean;
     }[];
 }>;
-declare type PluginDependenciesResponse = z.infer<typeof dependenciesResponseSchema>;
-declare type t = PluginDependenciesResponse;
-declare const of: (input: unknown) => fluture.FutureInstance<TaqError, {
+export declare type PluginDependenciesResponse = z.infer<typeof dependenciesResponseSchema>;
+export declare type t = PluginDependenciesResponse;
+export declare const of: (input: unknown) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
     path: string;
     name: string;
     version: string;
     kind: "required" | "optional";
 } & {
     readonly __kind: any;
-}>;
-declare const make: (input: {
+}>, make: (input: {
     path: string;
     name: string;
     version: string;
     kind: "required" | "optional";
-}) => fluture.FutureInstance<TaqError, {
+}) => import("fluture").FutureInstance<import("./TaqError").TaqError, {
     path: string;
     name: string;
     version: string;
     kind: "required" | "optional";
 } & {
     readonly __kind: any;
-}>;
-declare const create: (input: {
+}>, create: (input: {
     path: string;
     name: string;
     version: string;
@@ -154,5 +148,5 @@ declare const create: (input: {
 } & {
     readonly __kind: any;
 };
-
-export { PluginDependenciesResponse, RuntimeDependency, RuntimeDependencyReport, create, factory, make, of, schemas, t };
+export {};
+//# sourceMappingURL=PluginDependenciesResponse.d.ts.map

package/PluginDependenciesResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginDependenciesResponse.d.ts","sourceRoot":"","sources":["PluginDependenciesResponse.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAQ,OAAO;;;;;;;;;;;GAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK7B,CAAC;AAEH,oBAAY,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC;AAE/D,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;EAAoD,CAAC;AAElF,oBAAY,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE9B,CAAC;AAEH,oBAAY,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AACpF,oBAAY,CAAC,GAAG,0BAA0B,CAAC;AAE3C,eAAO,MAAQ,EAAE;;;;;;;IAAE,IAAI;;;;;;;;;;;;IAAE,MAAM;;;;;;;;;;;;CAAY,CAAC"}