@taqueria/protocol/taqueria-protocol-types.js

A TypeScript package which contains types that are to be shared between @taqueria/node-sdk and @taqueria/taqueria.

"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, from46, except, desc) => {
  if (from46 && typeof from46 === "object" || typeof from46 === "function") {
    for (let key of __getOwnPropNames(from46))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from46[key], enumerable: !(desc = __getOwnPropDesc(from46, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// taqueria-protocol-types.ts
var taqueria_protocol_types_exports = {};
__export(taqueria_protocol_types_exports, {
  Alias: () => Alias_exports,
  Config: () => Config_exports,
  EconomicalProtocolHash: () => EconomicalProtocolHash_exports,
  Environment: () => Environment_exports,
  EphemeralState: () => EphemeralState_exports,
  HumanReadableIdentifier: () => HumanReadableIdentifier_exports,
  InstalledPlugin: () => InstalledPlugin_exports,
  LoadedConfig: () => LoadedConfig_exports,
  MetadataConfig: () => MetadataConfig_exports,
  NetworkConfig: () => NetworkConfig_exports,
  Operation: () => Operation_exports,
  Option: () => Option_exports,
  ParsedOperation: () => ParsedOperation_exports,
  ParsedTemplate: () => ParsedTemplate_exports,
  PersistentState: () => PersistentState_exports,
  PluginActionName: () => PluginActionName_exports,
  PluginInfo: () => PluginInfo_exports,
  PluginJsonResponse: () => PluginJsonResponse_exports,
  PluginResponseEncoding: () => PluginResponseEncoding_exports,
  PluginSchema: () => PluginSchema_exports,
  PositionalArg: () => PositionalArg_exports,
  RequestArgs: () => RequestArgs_exports,
  SHA256: () => SHA256_exports,
  SandboxAccountConfig: () => SandboxAccountConfig_exports,
  SandboxConfig: () => SandboxConfig_exports,
  SanitizedAbsPath: () => SanitizedAbsPath_exports,
  SanitizedArgs: () => SanitizedArgs_exports,
  SanitizedPath: () => SanitizedPath_exports,
  ScaffoldConfig: () => ScaffoldConfig_exports,
  TaqError: () => TaqError_exports,
  Task: () => Task_exports,
  Template: () => Template_exports,
  Url: () => Url_exports,
  Verb: () => Verb_exports,
  VersionNumber: () => VersionNumber_exports,
  i18n: () => i18n_exports
});
module.exports = __toCommonJS(taqueria_protocol_types_exports);

// Alias.ts
var Alias_exports = {};
__export(Alias_exports, {
  create: () => create2,
  from: () => from,
  internalSchema: () => internalSchema,
  make: () => make,
  of: () => of,
  rawSchema: () => rawSchema,
  schemas: () => schemas
});

// TaqError.ts
var TaqError_exports = {};
__export(TaqError_exports, {
  E_TaqError: () => E_TaqError,
  create: () => create,
  toFutureParseErr: () => toFutureParseErr,
  toFutureParseUnknownErr: () => toFutureParseUnknownErr,
  toParseErr: () => toParseErr,
  toParseUnknownErr: () => toParseUnknownErr
});
var import_fluture = require("fluture");
var E_TaqError = class extends Error {
  constructor(taqErr) {
    super(taqErr.msg);
    this.context = taqErr.context;
    this.kind = taqErr.kind;
    this.name = this.kind;
    this.previous = taqErr.previous;
  }
};
var toFutureParseErr = (previous, msg, context) => (0, import_fluture.reject)(toParseErr(previous, msg, context)).pipe((0, import_fluture.map)((val) => val));
var toParseErr = (previous, msg, context) => create({
  kind: "E_PARSE",
  msg,
  context,
  previous
});
var toParseUnknownErr = (previous, msg, context) => create({
  kind: "E_PARSE_UNKNOWN",
  msg,
  context,
  previous
});
var toFutureParseUnknownErr = (previous, msg, context) => (0, import_fluture.reject)(toParseUnknownErr(previous, msg, context)).pipe((0, import_fluture.map)((val) => val));
var create = (err) => err;

// out/types/Alias.ts
var import_fluture2 = require("fluture");
var import_zod2 = require("zod");

// out/types-zod.ts
var import_zod = require("zod");
var nonEmptyStringSchema = import_zod.z.string().min(1);
var singleCharSchema = nonEmptyStringSchema.regex(/^[A-Za-z]$/);
var verbSchema = nonEmptyStringSchema.regex(/^[A-Za-z\-\ ]+/);
var aliasSchema = import_zod.z.union([verbSchema, singleCharSchema]);
var humanReadableIdentifierSchema = nonEmptyStringSchema.regex(
  /^[A-Za-z]+[A-Za-z0-9-_ ]*$/
);
var sanitizedAbsPathSchema = nonEmptyStringSchema;
var sanitizedPathSchema = nonEmptyStringSchema;
var settingsSchema = import_zod.z.object({
  consent: import_zod.z.union([
    import_zod.z.literal("opt_in"),
    import_zod.z.literal("opt_out"),
    import_zod.z.literal("unspecified")
  ])
});
var timestampSchema = import_zod.z.number().min(1651846877);
var tzSchema = nonEmptyStringSchema.min(1).regex(/^\d([\d_]+\d)?$/);
var versionNumberSchema = nonEmptyStringSchema.min(1).regex(/^\d+\.\d+(\.\d+)*$/);
var urlSchema = nonEmptyStringSchema.url();
var commandSchema = nonEmptyStringSchema.regex(
  /^([A-Za-z-_ ]+ ?)((\[.+\] ?)|(\<.+\>) ?)*$/
);
var optionSchema = import_zod.z.object({
  shortFlag: singleCharSchema.optional(),
  flag: verbSchema,
  description: nonEmptyStringSchema,
  defaultValue: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()]).optional(),
  type: import_zod.z.union([
    import_zod.z.literal("string"),
    import_zod.z.literal("number"),
    import_zod.z.literal("boolean"),
    import_zod.z.literal("count")
  ]).optional(),
  required: import_zod.z.boolean().optional(),
  boolean: import_zod.z.boolean().optional(),
  choices: import_zod.z.array(nonEmptyStringSchema).optional()
});
var positionalArgSchema = import_zod.z.object({
  placeholder: humanReadableIdentifierSchema,
  description: nonEmptyStringSchema,
  defaultValue: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()]).optional(),
  type: import_zod.z.union([import_zod.z.literal("string"), import_zod.z.literal("number"), import_zod.z.literal("boolean")]).optional(),
  required: import_zod.z.boolean().optional()
});
var installedPluginSchema = import_zod.z.object({
  type: import_zod.z.union([import_zod.z.literal("npm"), import_zod.z.literal("binary"), import_zod.z.literal("deno")]),
  name: nonEmptyStringSchema
});
var pluginResponseEncodingSchema = import_zod.z.union([import_zod.z.literal("none"), import_zod.z.literal("json"), import_zod.z.literal("application/json")]).default("none");
var taskSchema = import_zod.z.object({
  task: verbSchema,
  command: commandSchema,
  aliases: import_zod.z.array(aliasSchema).optional(),
  description: nonEmptyStringSchema.min(3).optional(),
  example: nonEmptyStringSchema.optional(),
  hidden: import_zod.z.boolean().optional(),
  encoding: pluginResponseEncodingSchema.optional(),
  handler: import_zod.z.union([import_zod.z.literal("proxy"), nonEmptyStringSchema]),
  options: import_zod.z.array(optionSchema).optional(),
  positionals: import_zod.z.array(positionalArgSchema).optional()
});
var pluginSchemaBaseSchema = import_zod.z.object({
  name: nonEmptyStringSchema,
  version: versionNumberSchema,
  schema: versionNumberSchema,
  alias: aliasSchema,
  tasks: import_zod.z.array(taskSchema).optional(),
  postInstall: import_zod.z.string().optional()
});
var runtimeDependencySchema = import_zod.z.object({
  name: humanReadableIdentifierSchema,
  path: import_zod.z.string(),
  version: import_zod.z.string(),
  kind: import_zod.z.union([import_zod.z.literal("required"), import_zod.z.literal("optional")])
});
var runtimeDependencyReportSchema = runtimeDependencySchema.extend(
  {
    met: import_zod.z.boolean()
  }
);
var pluginDependenciesResponseSchema = import_zod.z.object({
  report: import_zod.z.array(runtimeDependencyReportSchema)
});
var pluginJsonResponseSchema = import_zod.z.union([
  import_zod.z.object({
    data: import_zod.z.unknown().optional(),
    messages: import_zod.z.object({
      header: import_zod.z.string().optional(),
      footer: import_zod.z.string().optional()
    }).optional(),
    render: import_zod.z.union([import_zod.z.literal("none"), import_zod.z.literal("table"), import_zod.z.literal("string")]).default("none")
  }),
  import_zod.z.void()
]);
var pluginProxyResponseSchema = import_zod.z.union([
  import_zod.z.void(),
  pluginJsonResponseSchema
]);
var buildNumberSchema = import_zod.z.number();
var sanitizedArgsSchema = import_zod.z.object({
  _: import_zod.z.array(import_zod.z.string()),
  projectDir: sanitizedPathSchema,
  maxConcurrency: import_zod.z.number(),
  debug: import_zod.z.boolean(),
  disableState: import_zod.z.boolean(),
  logPluginRequests: import_zod.z.boolean(),
  fromVsCode: import_zod.z.boolean(),
  version: import_zod.z.boolean(),
  build: import_zod.z.boolean(),
  help: import_zod.z.boolean(),
  yes: import_zod.z.boolean(),
  plugin: nonEmptyStringSchema.optional(),
  env: nonEmptyStringSchema,
  quickstart: nonEmptyStringSchema,
  setBuild: import_zod.z.union([nonEmptyStringSchema, buildNumberSchema]),
  setVersion: nonEmptyStringSchema
}).passthrough();
var pluginActionNameSchema = import_zod.z.union([
  import_zod.z.literal("proxy"),
  import_zod.z.literal("pluginInfo"),
  import_zod.z.literal("checkRuntimeDependencies"),
  import_zod.z.literal("installRuntimeDependencies"),
  import_zod.z.literal("runPostInstall"),
  import_zod.z.literal("proxyTemplate")
]);
var economicalProtocolHashSchema = import_zod.z.string();
var publicKeyHashSchema = import_zod.z.string().regex(/^tz\d[A-Za-z0-9]{33}$/);
var sha256Schema = import_zod.z.string().regex(/^[A-Fa-f0-9]{64}$/);
var contractSchema = import_zod.z.object({
  sourceFile: nonEmptyStringSchema,
  hash: sha256Schema
});
var faucetSchema = import_zod.z.object({
  pkh: publicKeyHashSchema,
  mnemonic: import_zod.z.array(import_zod.z.string()),
  email: import_zod.z.string().email(),
  password: import_zod.z.string(),
  amount: import_zod.z.string().regex(/^\d+$/),
  activation_code: import_zod.z.string()
});
var tzKtConfigPostgresqlPortSchema = import_zod.z.number().default(5432);
var tzKtConfigApiPortSchema = import_zod.z.number().default(5e3);
var tzKtConfigSchema = import_zod.z.object({
  disableAutostartWithSandbox: import_zod.z.boolean().optional(),
  postgresqlPort: tzKtConfigPostgresqlPortSchema.optional(),
  apiPort: tzKtConfigApiPortSchema.optional()
});
var persistedOperationSchema = import_zod.z.object({
  hash: sha256Schema,
  time: timestampSchema,
  output: import_zod.z.unknown().optional()
});
var persistedTaskSchema = import_zod.z.object({
  task: verbSchema,
  plugin: nonEmptyStringSchema,
  time: timestampSchema,
  output: import_zod.z.unknown().optional()
});
var provisionerIDSchema = import_zod.z.string().min(1).regex(
  /^[A-Za-z0-9]+[A-Za-z0-9-_]+\.[A-Za-z0-9]+[A-Za-z0-9-_]+\.[A-Za-z0-9]+[A-Za-z0-9-_]+$/
);
var provisionerSchema = import_zod.z.object({
  id: provisionerIDSchema,
  plugin: nonEmptyStringSchema,
  operation: import_zod.z.union([nonEmptyStringSchema, import_zod.z.literal("custom")]),
  command: import_zod.z.string().optional(),
  label: import_zod.z.string().optional(),
  depends_on: import_zod.z.array(provisionerIDSchema).optional()
});
var provisionsSchema = import_zod.z.array(provisionerSchema);
var environmentSchema = import_zod.z.object({
  networks: import_zod.z.array(nonEmptyStringSchema),
  sandboxes: import_zod.z.array(nonEmptyStringSchema),
  storage: import_zod.z.record(nonEmptyStringSchema).optional(),
  aliases: import_zod.z.record(import_zod.z.record(nonEmptyStringSchema)).optional()
});
var environmentNameSchema = nonEmptyStringSchema.min(
  1,
  "Default environment must reference the name of an existing environment."
);
var humanLanguageSchema = import_zod.z.union([import_zod.z.literal("en"), import_zod.z.literal("fr")]).default("en");
var configContractsDirSchema = import_zod.z.string().min(1).default("contracts");
var configArtifactsDirSchema = import_zod.z.string().min(1).default("artifacts");
var currencyAmountV2Schema = import_zod.z.object({
  amount: import_zod.z.string(),
  units: import_zod.z.string()
});
var metadataConfigSchema = import_zod.z.object({
  name: import_zod.z.string().optional(),
  projectDescription: import_zod.z.string().optional(),
  authors: import_zod.z.array(import_zod.z.string()).optional(),
  license: import_zod.z.string().optional(),
  homepage: import_zod.z.string().optional()
});
var versionV2Schema = import_zod.z.string().regex(/^v2$/);
var configAccountSchema = import_zod.z.object({
  balance: currencyAmountV2Schema
});
var sandboxAccountSchema = import_zod.z.object({
  type: import_zod.z.string().optional()
}).passthrough();
var sandboxAccountsSchema = import_zod.z.record(sandboxAccountSchema);
var configEnvironmentFileV2Schema = import_zod.z.object({
  type: import_zod.z.string().optional(),
  accounts: sandboxAccountsSchema.optional(),
  accountDefault: import_zod.z.any().optional(),
  contracts: import_zod.z.record(
    import_zod.z.object({
      address: import_zod.z.string().optional()
    })
  ).optional()
}).passthrough();
var networkAccountConfigSchema = import_zod.z.object({
  publicKey: nonEmptyStringSchema.optional(),
  publicKeyHash: publicKeyHashSchema.optional(),
  privateKey: nonEmptyStringSchema.optional(),
  mnemonic: nonEmptyStringSchema.optional()
});
var sandboxAccountConfigSchema = import_zod.z.object({
  encryptedKey: nonEmptyStringSchema.optional(),
  publicKeyHash: publicKeyHashSchema,
  secretKey: nonEmptyStringSchema
});
var sandboxConfigSchema = import_zod.z.object({
  label: nonEmptyStringSchema,
  rpcUrl: urlSchema,
  protocol: economicalProtocolHashSchema.optional(),
  plugin: verbSchema.optional(),
  blockTime: import_zod.z.number().optional(),
  baking: import_zod.z.union([import_zod.z.literal("enabled"), import_zod.z.literal("disabled")]).optional(),
  accounts: import_zod.z.record(import_zod.z.union([sandboxAccountConfigSchema, nonEmptyStringSchema])).optional(),
  tzkt: tzKtConfigSchema.optional(),
  annotations: import_zod.z.record(import_zod.z.unknown()).optional()
});
var scaffoldConfigSchema = import_zod.z.object({
  postInit: import_zod.z.string().optional()
});
var persistentStateSchema = import_zod.z.object({
  operations: import_zod.z.record(persistedOperationSchema),
  tasks: import_zod.z.record(persistedTaskSchema)
});
var networkConfigSchema = import_zod.z.object({
  label: humanReadableIdentifierSchema,
  rpcUrl: urlSchema,
  accounts: import_zod.z.record(networkAccountConfigSchema).optional(),
  faucet: faucetSchema.optional()
});
var configFileV1Schema = import_zod.z.object({
  language: humanLanguageSchema.optional(),
  plugins: import_zod.z.array(installedPluginSchema).optional(),
  contractsDir: configContractsDirSchema.optional(),
  artifactsDir: configArtifactsDirSchema.optional(),
  network: import_zod.z.record(networkConfigSchema).optional(),
  sandbox: import_zod.z.record(sandboxConfigSchema).optional(),
  environment: import_zod.z.record(import_zod.z.union([environmentSchema, environmentNameSchema])).optional(),
  accounts: import_zod.z.record(tzSchema).optional(),
  contracts: import_zod.z.record(contractSchema).optional(),
  metadata: metadataConfigSchema.optional()
});
var configFileV2Schema = import_zod.z.object({
  version: versionV2Schema,
  language: humanLanguageSchema.optional(),
  metadata: metadataConfigSchema.optional(),
  artifactsDir: configArtifactsDirSchema.optional(),
  contractsDir: configContractsDirSchema.optional(),
  accounts: import_zod.z.record(configAccountSchema).optional(),
  contracts: import_zod.z.record(contractSchema).optional(),
  environmentDefault: environmentNameSchema.optional(),
  environments: import_zod.z.record(configEnvironmentFileV2Schema).optional(),
  plugins: import_zod.z.array(installedPluginSchema).optional()
});
var configSchema = import_zod.z.object({
  language: humanLanguageSchema.optional(),
  metadata: metadataConfigSchema.optional(),
  artifactsDir: configArtifactsDirSchema.optional(),
  contractsDir: configContractsDirSchema.optional(),
  contracts: import_zod.z.record(contractSchema).optional(),
  plugins: import_zod.z.array(installedPluginSchema).optional(),
  accounts: import_zod.z.record(tzSchema).optional(),
  environment: import_zod.z.record(import_zod.z.union([environmentSchema, environmentNameSchema])),
  network: import_zod.z.record(networkConfigSchema).optional(),
  sandbox: import_zod.z.record(sandboxConfigSchema).optional()
});
var parsedConfigSchema = configSchema.omit({ sandbox: true }).extend(
  {
    sandbox: import_zod.z.record(import_zod.z.union([sandboxConfigSchema, nonEmptyStringSchema]))
  }
);
var loadedConfigSchema = configSchema.extend(
  {
    projectDir: sanitizedAbsPathSchema,
    configFile: sanitizedAbsPathSchema,
    hash: sha256Schema
  }
);
var requestArgsSchema = sanitizedArgsSchema.omit({ quickstart: true }).extend(
  {
    taqRun: pluginActionNameSchema,
    config: loadedConfigSchema
  }
).passthrough();
var proxyTemplateArgsSchema = requestArgsSchema.extend(
  {
    template: nonEmptyStringSchema
  }
).passthrough();
var operationSchema = import_zod.z.object({
  operation: verbSchema,
  command: commandSchema,
  description: nonEmptyStringSchema.optional(),
  positionals: import_zod.z.array(positionalArgSchema).optional(),
  options: import_zod.z.array(optionSchema).optional(),
  handler: import_zod.z.function().args(persistentStateSchema).returns(import_zod.z.function().args(requestArgsSchema).returns(import_zod.z.void())).optional()
});
var parsedOperationSchema = operationSchema.omit({ handler: true });
var templateHandlerSchema = import_zod.z.union([
  nonEmptyStringSchema,
  import_zod.z.function().args(requestArgsSchema).returns(
    import_zod.z.union([pluginJsonResponseSchema, import_zod.z.promise(pluginJsonResponseSchema)])
  ),
  import_zod.z.promise(import_zod.z.void())
]);
var templateSchema = import_zod.z.object({
  template: verbSchema,
  command: commandSchema,
  description: nonEmptyStringSchema,
  hidden: import_zod.z.boolean().optional(),
  options: import_zod.z.array(optionSchema).optional(),
  positionals: import_zod.z.array(positionalArgSchema).optional(),
  handler: templateHandlerSchema,
  encoding: pluginResponseEncodingSchema.optional()
});
var parsedTemplateSchema = templateSchema.omit({ handler: true }).extend(
  {
    handler: import_zod.z.string()
  }
);
var pluginSchemaSchema = pluginSchemaBaseSchema.extend(
  {
    operations: import_zod.z.array(operationSchema).optional(),
    templates: import_zod.z.array(templateSchema).optional(),
    proxy: import_zod.z.function().args(requestArgsSchema).returns(import_zod.z.promise(pluginProxyResponseSchema)).optional(),
    checkRuntimeDependencies: import_zod.z.function().args(requestArgsSchema).returns(import_zod.z.promise(pluginDependenciesResponseSchema)).optional(),
    installRuntimeDependencies: import_zod.z.function().args(requestArgsSchema).returns(import_zod.z.promise(pluginDependenciesResponseSchema)).optional()
  }
);
var proxyTaskArgsSchema = requestArgsSchema.extend(
  {
    task: nonEmptyStringSchema
  }
).passthrough();
var pluginInfoSchema = pluginSchemaBaseSchema.extend(
  {
    operations: import_zod.z.array(parsedOperationSchema).optional(),
    templates: import_zod.z.array(parsedTemplateSchema).optional()
  }
);
var ephemeralStateSchema = import_zod.z.object({
  build: import_zod.z.string(),
  configHash: import_zod.z.string(),
  tasks: import_zod.z.record(installedPluginSchema.and(taskSchema)),
  operations: import_zod.z.record(installedPluginSchema.and(parsedOperationSchema)),
  templates: import_zod.z.record(installedPluginSchema.and(parsedTemplateSchema)),
  plugins: import_zod.z.array(pluginInfoSchema)
});

// out/types/Alias.ts
var from = (input) => {
  try {
    return aliasSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod2.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["Alias is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a Alias.");
  }
};
var create2 = (input) => from(input);
var of = (input) => {
  try {
    return (0, import_fluture2.resolve)(from(input));
  } catch (err) {
    return (0, import_fluture2.reject)(err);
  }
};
var make = (input) => of(input);
var schemas = {
  rawSchema: aliasSchema,
  schema: aliasSchema.transform((val) => val)
};
var rawSchema = schemas.rawSchema;
var internalSchema = aliasSchema;

// Config.ts
var Config_exports = {};
__export(Config_exports, {
  create: () => create3,
  from: () => from2,
  internalSchema: () => internalSchema2,
  make: () => make2,
  of: () => of2,
  rawSchema: () => rawSchema2,
  schemas: () => schemas2
});

// out/types/Config.ts
var import_fluture3 = require("fluture");
var import_zod3 = require("zod");
var from2 = (input) => {
  try {
    return configSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod3.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["Your .taq/config.json is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a Config.");
  }
};
var create3 = (input) => from2(input);
var of2 = (input) => {
  try {
    return (0, import_fluture3.resolve)(from2(input));
  } catch (err) {
    return (0, import_fluture3.reject)(err);
  }
};
var make2 = (input) => of2(input);
var schemas2 = {
  rawSchema: configSchema,
  schema: configSchema.transform((val) => val)
};
var rawSchema2 = schemas2.rawSchema;
var internalSchema2 = configSchema;

// EconomicalProtocolHash.ts
var EconomicalProtocolHash_exports = {};
__export(EconomicalProtocolHash_exports, {
  create: () => create4,
  from: () => from3,
  internalSchema: () => internalSchema3,
  make: () => make3,
  of: () => of3,
  rawSchema: () => rawSchema3,
  schemas: () => schemas3
});

// out/types/EconomicalProtocolHash.ts
var import_fluture4 = require("fluture");
var import_zod4 = require("zod");
var from3 = (input) => {
  try {
    return economicalProtocolHashSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod4.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["EconomicalProtocolHash is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a EconomicalProtocolHash.");
  }
};
var create4 = (input) => from3(input);
var of3 = (input) => {
  try {
    return (0, import_fluture4.resolve)(from3(input));
  } catch (err) {
    return (0, import_fluture4.reject)(err);
  }
};
var make3 = (input) => of3(input);
var schemas3 = {
  rawSchema: economicalProtocolHashSchema,
  schema: economicalProtocolHashSchema.transform((val) => val)
};
var rawSchema3 = schemas3.rawSchema;
var internalSchema3 = economicalProtocolHashSchema;

// Environment.ts
var Environment_exports = {};
__export(Environment_exports, {
  create: () => create5,
  from: () => from4,
  internalSchema: () => internalSchema4,
  make: () => make4,
  of: () => of4,
  rawSchema: () => rawSchema4,
  schemas: () => schemas4
});

// out/types/Environment.ts
var import_fluture5 = require("fluture");
var import_zod5 = require("zod");
var from4 = (input) => {
  try {
    return environmentSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod5.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["Environment is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a Environment.");
  }
};
var create5 = (input) => from4(input);
var of4 = (input) => {
  try {
    return (0, import_fluture5.resolve)(from4(input));
  } catch (err) {
    return (0, import_fluture5.reject)(err);
  }
};
var make4 = (input) => of4(input);
var schemas4 = {
  rawSchema: environmentSchema,
  schema: environmentSchema.transform((val) => val)
};
var rawSchema4 = schemas4.rawSchema;
var internalSchema4 = environmentSchema;

// EphemeralState.ts
var EphemeralState_exports = {};
__export(EphemeralState_exports, {
  create: () => create54,
  factory: () => factory7,
  generatedSchemas: () => generatedSchemas6,
  getTasks: () => getTasks,
  make: () => make52,
  mapOperationsToPlugins: () => mapOperationsToPlugins,
  mapTasksToPlugins: () => mapTasksToPlugins,
  mapTemplatesToPlugins: () => mapTemplatesToPlugins,
  of: () => of52,
  schemas: () => schemas52
});

// Command.ts
var Command_exports = {};
__export(Command_exports, {
  create: () => create6,
  from: () => from5,
  internalSchema: () => internalSchema5,
  make: () => make5,
  of: () => of5,
  rawSchema: () => rawSchema5,
  schemas: () => schemas5
});

// out/types/Command.ts
var import_fluture6 = require("fluture");
var import_zod6 = require("zod");
var from5 = (input) => {
  try {
    return commandSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod6.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["Command is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a Command.");
  }
};
var create6 = (input) => from5(input);
var of5 = (input) => {
  try {
    return (0, import_fluture6.resolve)(from5(input));
  } catch (err) {
    return (0, import_fluture6.reject)(err);
  }
};
var make5 = (input) => of5(input);
var schemas5 = {
  rawSchema: commandSchema,
  schema: commandSchema.transform((val) => val)
};
var rawSchema5 = schemas5.rawSchema;
var internalSchema5 = commandSchema;

// ConfigFileV2.ts
var ConfigFileV2_exports = {};
__export(ConfigFileV2_exports, {
  create: () => create7,
  from: () => from6,
  internalSchema: () => internalSchema6,
  make: () => make6,
  of: () => of6,
  rawSchema: () => rawSchema6,
  schemas: () => schemas6
});

// out/types/ConfigFileV2.ts
var import_fluture7 = require("fluture");
var import_zod7 = require("zod");
var from6 = (input) => {
  try {
    return configFileV2Schema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod7.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["ConfigFileV2 is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a ConfigFileV2.");
  }
};
var create7 = (input) => from6(input);
var of6 = (input) => {
  try {
    return (0, import_fluture7.resolve)(from6(input));
  } catch (err) {
    return (0, import_fluture7.reject)(err);
  }
};
var make6 = (input) => of6(input);
var schemas6 = {
  rawSchema: configFileV2Schema,
  schema: configFileV2Schema.transform((val) => val)
};
var rawSchema6 = schemas6.rawSchema;
var internalSchema6 = configFileV2Schema;

// Contract.ts
var Contract_exports = {};
__export(Contract_exports, {
  create: () => create8,
  from: () => from7,
  internalSchema: () => internalSchema7,
  make: () => make7,
  of: () => of7,
  rawSchema: () => rawSchema7,
  schemas: () => schemas7
});

// out/types/Contract.ts
var import_fluture8 = require("fluture");
var import_zod8 = require("zod");
var from7 = (input) => {
  try {
    return contractSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod8.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["Contract is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a Contract.");
  }
};
var create8 = (input) => from7(input);
var of7 = (input) => {
  try {
    return (0, import_fluture8.resolve)(from7(input));
  } catch (err) {
    return (0, import_fluture8.reject)(err);
  }
};
var make7 = (input) => of7(input);
var schemas7 = {
  rawSchema: contractSchema,
  schema: contractSchema.transform((val) => val)
};
var rawSchema7 = schemas7.rawSchema;
var internalSchema7 = contractSchema;

// Faucet.ts
var Faucet_exports = {};
__export(Faucet_exports, {
  create: () => create9,
  from: () => from8,
  internalSchema: () => internalSchema8,
  make: () => make8,
  of: () => of8,
  rawSchema: () => rawSchema8,
  schemas: () => schemas8
});

// out/types/Faucet.ts
var import_fluture9 = require("fluture");
var import_zod9 = require("zod");
var from8 = (input) => {
  try {
    return faucetSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod9.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["Faucet is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a Faucet.");
  }
};
var create9 = (input) => from8(input);
var of8 = (input) => {
  try {
    return (0, import_fluture9.resolve)(from8(input));
  } catch (err) {
    return (0, import_fluture9.reject)(err);
  }
};
var make8 = (input) => of8(input);
var schemas8 = {
  rawSchema: faucetSchema,
  schema: faucetSchema.transform((val) => val)
};
var rawSchema8 = schemas8.rawSchema;
var internalSchema8 = faucetSchema;

// HumanReadableIdentifier.ts
var HumanReadableIdentifier_exports = {};
__export(HumanReadableIdentifier_exports, {
  create: () => create10,
  from: () => from9,
  internalSchema: () => internalSchema9,
  make: () => make9,
  of: () => of9,
  rawSchema: () => rawSchema9,
  schemas: () => schemas9
});

// out/types/HumanReadableIdentifier.ts
var import_fluture10 = require("fluture");
var import_zod10 = require("zod");
var from9 = (input) => {
  try {
    return humanReadableIdentifierSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod10.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["HumanReadableIdentifier is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a HumanReadableIdentifier.");
  }
};
var create10 = (input) => from9(input);
var of9 = (input) => {
  try {
    return (0, import_fluture10.resolve)(from9(input));
  } catch (err) {
    return (0, import_fluture10.reject)(err);
  }
};
var make9 = (input) => of9(input);
var schemas9 = {
  rawSchema: humanReadableIdentifierSchema,
  schema: humanReadableIdentifierSchema.transform((val) => val)
};
var rawSchema9 = schemas9.rawSchema;
var internalSchema9 = humanReadableIdentifierSchema;

// InstalledPlugin.ts
var InstalledPlugin_exports = {};
__export(InstalledPlugin_exports, {
  create: () => create11,
  from: () => from10,
  internalSchema: () => internalSchema10,
  make: () => make10,
  of: () => of10,
  rawSchema: () => rawSchema10,
  schemas: () => schemas10
});

// out/types/InstalledPlugin.ts
var import_fluture11 = require("fluture");
var import_zod11 = require("zod");
var from10 = (input) => {
  try {
    return installedPluginSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod11.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["InstalledPlugin is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a InstalledPlugin.");
  }
};
var create11 = (input) => from10(input);
var of10 = (input) => {
  try {
    return (0, import_fluture11.resolve)(from10(input));
  } catch (err) {
    return (0, import_fluture11.reject)(err);
  }
};
var make10 = (input) => of10(input);
var schemas10 = {
  rawSchema: installedPluginSchema,
  schema: installedPluginSchema.transform((val) => val)
};
var rawSchema10 = schemas10.rawSchema;
var internalSchema10 = installedPluginSchema;

// LoadedConfig.ts
var LoadedConfig_exports = {};
__export(LoadedConfig_exports, {
  create: () => create12,
  from: () => from11,
  internalSchema: () => internalSchema11,
  make: () => make11,
  of: () => of11,
  rawSchema: () => rawSchema11,
  schemas: () => schemas11
});

// out/types/LoadedConfig.ts
var import_fluture12 = require("fluture");
var import_zod12 = require("zod");
var from11 = (input) => {
  try {
    return loadedConfigSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod12.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["Your .taq/config.json is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a LoadedConfig.");
  }
};
var create12 = (input) => from11(input);
var of11 = (input) => {
  try {
    return (0, import_fluture12.resolve)(from11(input));
  } catch (err) {
    return (0, import_fluture12.reject)(err);
  }
};
var make11 = (input) => of11(input);
var schemas11 = {
  rawSchema: loadedConfigSchema,
  schema: loadedConfigSchema.transform((val) => val)
};
var rawSchema11 = schemas11.rawSchema;
var internalSchema11 = loadedConfigSchema;

// MetadataConfig.ts
var MetadataConfig_exports = {};
__export(MetadataConfig_exports, {
  create: () => create13,
  from: () => from12,
  internalSchema: () => internalSchema12,
  make: () => make12,
  of: () => of12,
  rawSchema: () => rawSchema12,
  schemas: () => schemas12
});

// out/types/MetadataConfig.ts
var import_fluture13 = require("fluture");
var import_zod13 = require("zod");
var from12 = (input) => {
  try {
    return metadataConfigSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod13.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["MetadataConfig is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a MetadataConfig.");
  }
};
var create13 = (input) => from12(input);
var of12 = (input) => {
  try {
    return (0, import_fluture13.resolve)(from12(input));
  } catch (err) {
    return (0, import_fluture13.reject)(err);
  }
};
var make12 = (input) => of12(input);
var schemas12 = {
  rawSchema: metadataConfigSchema,
  schema: metadataConfigSchema.transform((val) => val)
};
var rawSchema12 = schemas12.rawSchema;
var internalSchema12 = metadataConfigSchema;

// NetworkAccountConfig.ts
var NetworkAccountConfig_exports = {};
__export(NetworkAccountConfig_exports, {
  create: () => create14,
  from: () => from13,
  internalSchema: () => internalSchema13,
  make: () => make13,
  of: () => of13,
  rawSchema: () => rawSchema13,
  schemas: () => schemas13
});

// out/types/NetworkAccountConfig.ts
var import_fluture14 = require("fluture");
var import_zod14 = require("zod");
var from13 = (input) => {
  try {
    return networkAccountConfigSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod14.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["NetworkAccountConfig is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a NetworkAccountConfig.");
  }
};
var create14 = (input) => from13(input);
var of13 = (input) => {
  try {
    return (0, import_fluture14.resolve)(from13(input));
  } catch (err) {
    return (0, import_fluture14.reject)(err);
  }
};
var make13 = (input) => of13(input);
var schemas13 = {
  rawSchema: networkAccountConfigSchema,
  schema: networkAccountConfigSchema.transform((val) => val)
};
var rawSchema13 = schemas13.rawSchema;
var internalSchema13 = networkAccountConfigSchema;

// NetworkConfig.ts
var NetworkConfig_exports = {};
__export(NetworkConfig_exports, {
  create: () => create15,
  from: () => from14,
  internalSchema: () => internalSchema14,
  make: () => make14,
  of: () => of14,
  rawSchema: () => rawSchema14,
  schemas: () => schemas14
});

// out/types/NetworkConfig.ts
var import_fluture15 = require("fluture");
var import_zod15 = require("zod");
var from14 = (input) => {
  try {
    return networkConfigSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod15.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["NetworkConfig is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a NetworkConfig.");
  }
};
var create15 = (input) => from14(input);
var of14 = (input) => {
  try {
    return (0, import_fluture15.resolve)(from14(input));
  } catch (err) {
    return (0, import_fluture15.reject)(err);
  }
};
var make14 = (input) => of14(input);
var schemas14 = {
  rawSchema: networkConfigSchema,
  schema: networkConfigSchema.transform((val) => val)
};
var rawSchema14 = schemas14.rawSchema;
var internalSchema14 = networkConfigSchema;

// NonEmptyString.ts
var NonEmptyString_exports = {};
__export(NonEmptyString_exports, {
  create: () => create16,
  from: () => from15,
  internalSchema: () => internalSchema15,
  make: () => make15,
  of: () => of15,
  rawSchema: () => rawSchema15,
  schemas: () => schemas15
});

// out/types/NonEmptyString.ts
var import_fluture16 = require("fluture");
var import_zod16 = require("zod");
var from15 = (input) => {
  try {
    return nonEmptyStringSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod16.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["NonEmptyString is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a NonEmptyString.");
  }
};
var create16 = (input) => from15(input);
var of15 = (input) => {
  try {
    return (0, import_fluture16.resolve)(from15(input));
  } catch (err) {
    return (0, import_fluture16.reject)(err);
  }
};
var make15 = (input) => of15(input);
var schemas15 = {
  rawSchema: nonEmptyStringSchema,
  schema: nonEmptyStringSchema.transform((val) => val)
};
var rawSchema15 = schemas15.rawSchema;
var internalSchema15 = nonEmptyStringSchema;

// Operation.ts
var Operation_exports = {};
__export(Operation_exports, {
  create: () => create17,
  from: () => from16,
  internalSchema: () => internalSchema16,
  make: () => make16,
  of: () => of16,
  rawSchema: () => rawSchema16,
  schemas: () => schemas16
});

// out/types/Operation.ts
var import_fluture17 = require("fluture");
var import_zod17 = require("zod");
var from16 = (input) => {
  try {
    return operationSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod17.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["Operation is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a Operation.");
  }
};
var create17 = (input) => from16(input);
var of16 = (input) => {
  try {
    return (0, import_fluture17.resolve)(from16(input));
  } catch (err) {
    return (0, import_fluture17.reject)(err);
  }
};
var make16 = (input) => of16(input);
var schemas16 = {
  rawSchema: operationSchema,
  schema: operationSchema.transform((val) => val)
};
var rawSchema16 = schemas16.rawSchema;
var internalSchema16 = operationSchema;

// Option.ts
var Option_exports = {};
__export(Option_exports, {
  create: () => create18,
  from: () => from17,
  internalSchema: () => internalSchema17,
  make: () => make17,
  of: () => of17,
  rawSchema: () => rawSchema17,
  schemas: () => schemas17
});

// out/types/Option.ts
var import_fluture18 = require("fluture");
var import_zod18 = require("zod");
var from17 = (input) => {
  try {
    return optionSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod18.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["Option is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a Option.");
  }
};
var create18 = (input) => from17(input);
var of17 = (input) => {
  try {
    return (0, import_fluture18.resolve)(from17(input));
  } catch (err) {
    return (0, import_fluture18.reject)(err);
  }
};
var make17 = (input) => of17(input);
var schemas17 = {
  rawSchema: optionSchema,
  schema: optionSchema.transform((val) => val)
};
var rawSchema17 = schemas17.rawSchema;
var internalSchema17 = optionSchema;

// ParsedOperation.ts
var ParsedOperation_exports = {};
__export(ParsedOperation_exports, {
  create: () => create19,
  from: () => from18,
  internalSchema: () => internalSchema18,
  make: () => make18,
  of: () => of18,
  rawSchema: () => rawSchema18,
  schemas: () => schemas18
});

// out/types/ParsedOperation.ts
var import_fluture19 = require("fluture");
var import_zod19 = require("zod");
var from18 = (input) => {
  try {
    return parsedOperationSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod19.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["ParsedOperation is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a ParsedOperation.");
  }
};
var create19 = (input) => from18(input);
var of18 = (input) => {
  try {
    return (0, import_fluture19.resolve)(from18(input));
  } catch (err) {
    return (0, import_fluture19.reject)(err);
  }
};
var make18 = (input) => of18(input);
var schemas18 = {
  rawSchema: parsedOperationSchema,
  schema: parsedOperationSchema.transform((val) => val)
};
var rawSchema18 = schemas18.rawSchema;
var internalSchema18 = parsedOperationSchema;

// ParsedTemplate.ts
var ParsedTemplate_exports = {};
__export(ParsedTemplate_exports, {
  create: () => create20,
  from: () => from19,
  internalSchema: () => internalSchema19,
  make: () => make19,
  of: () => of19,
  rawSchema: () => rawSchema19,
  schemas: () => schemas19
});

// out/types/ParsedTemplate.ts
var import_fluture20 = require("fluture");
var import_zod20 = require("zod");
var from19 = (input) => {
  try {
    return parsedTemplateSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod20.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["ParsedTemplate is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a ParsedTemplate.");
  }
};
var create20 = (input) => from19(input);
var of19 = (input) => {
  try {
    return (0, import_fluture20.resolve)(from19(input));
  } catch (err) {
    return (0, import_fluture20.reject)(err);
  }
};
var make19 = (input) => of19(input);
var schemas19 = {
  rawSchema: parsedTemplateSchema,
  schema: parsedTemplateSchema.transform((val) => val)
};
var rawSchema19 = schemas19.rawSchema;
var internalSchema19 = parsedTemplateSchema;

// PluginActionName.ts
var PluginActionName_exports = {};
__export(PluginActionName_exports, {
  create: () => create21,
  from: () => from20,
  internalSchema: () => internalSchema20,
  make: () => make20,
  of: () => of20,
  rawSchema: () => rawSchema20,
  schemas: () => schemas20
});

// out/types/PluginActionName.ts
var import_fluture21 = require("fluture");
var import_zod21 = require("zod");
var from20 = (input) => {
  try {
    return pluginActionNameSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod21.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.join(" \u2192 ");
          const msg = path2 + ": " + issue.message;
          return [...retval, msg];
        },
        ["PluginActionName is invalid:"]
      );
      const validationErr = msgs.join("\n") + "\n";
      throw toParseErr(previous, validationErr);
    }
    throw toParseUnknownErr(previous, "There was a problem trying to parse a PluginActionName.");
  }
};
var create21 = (input) => from20(input);
var of20 = (input) => {
  try {
    return (0, import_fluture21.resolve)(from20(input));
  } catch (err) {
    return (0, import_fluture21.reject)(err);
  }
};
var make20 = (input) => of20(input);
var schemas20 = {
  rawSchema: pluginActionNameSchema,
  schema: pluginActionNameSchema.transform((val) => val)
};
var rawSchema20 = schemas20.rawSchema;
var internalSchema20 = pluginActionNameSchema;

// PluginDependenciesResponse.ts
var PluginDependenciesResponse_exports = {};
__export(PluginDependenciesResponse_exports, {
  create: () => create22,
  from: () => from21,
  internalSchema: () => internalSchema21,
  make: () => make21,
  of: () => of21,
  rawSchema: () => rawSchema21,
  schemas: () => schemas21
});

// out/types/PluginDependenciesResponse.ts
var import_fluture22 = require("fluture");
var import_zod22 = require("zod");
var from21 = (input) => {
  try {
    return pluginDependenciesResponseSchema.parse(input);
  } catch (previous) {
    if (previous instanceof import_zod22.ZodError) {
      const msgs = previous.errors.reduce(
        (retval, issue) => {
          const path2 = issue.path.