@taqueria/protocol/SanitizedArgs.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, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, 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);

// SanitizedArgs.ts
var SanitizedArgs_exports = {};
__export(SanitizedArgs_exports, {
  create: () => create3,
  createCreateTaskArgs: () => createCreateTaskArgs,
  createInstallTaskArgs: () => createInstallTaskArgs,
  createProvisionTaskArgs: () => createProvisionTaskArgs,
  createScaffoldTaskArgs: () => createScaffoldTaskArgs,
  createSetEnvTaskArgs: () => createSetEnvTaskArgs,
  createTaskArgs: () => createTaskArgs,
  createUninstallTaskArgs: () => createUninstallTaskArgs,
  factory: () => factory2,
  generatedSchemas: () => generatedSchemas2,
  initRawSchema: () => initRawSchema,
  installTaskArgs: () => installTaskArgs,
  make: () => make2,
  makeCreateTaskArgs: () => makeCreateTaskArgs,
  makeInstallTaskArgs: () => makeInstallTaskArgs,
  makeProvisionTaskArgs: () => makeProvisionTaskArgs,
  makeScaffoldTaskArgs: () => makeScaffoldTaskArgs,
  makeSetEnvTaskArgs: () => makeSetEnvTaskArgs,
  makeUninstallTaskArgs: () => makeUninstallTaskArgs,
  managePluginRawSchema: () => managePluginRawSchema,
  of: () => of2,
  ofCreateTaskArgs: () => ofCreateTaskArgs,
  ofInstallTaskArgs: () => ofInstallTaskArgs,
  ofProvisionTaskArgs: () => ofProvisionTaskArgs,
  ofScaffoldTaskArgs: () => ofScaffoldTaskArgs,
  ofSetEnvTaskArgs: () => ofSetEnvTaskArgs,
  ofUninstallTaskArgs: () => ofUninstallTaskArgs,
  provisionRawSchema: () => provisionRawSchema,
  provisionTaskArgs: () => provisionTaskArgs,
  rawSchema: () => rawSchema3,
  scaffoldRawSchema: () => scaffoldRawSchema,
  scaffoldTaskArgs: () => scaffoldTaskArgs,
  schemas: () => schemas3,
  setEnvRawSchema: () => setEnvRawSchema,
  setEnvTaskArgs: () => setEnvTaskArgs,
  templateRawSchema: () => templateRawSchema,
  uninstallTaskArgs: () => uninstallTaskArgs
});
module.exports = __toCommonJS(SanitizedArgs_exports);

// TaqError.ts
var import_fluture = require("fluture");
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;

// Base.ts
var import_fluture2 = require("fluture");
var import_zod = require("zod");
var createSchema = (params) => {
  var _a, _b;
  const { rawSchema: rawSchema4, isStringLike } = params;
  const internalSchema = (_a = params.internalSchema) != null ? _a : params.rawSchema;
  const noop = (val) => val;
  const transformer = (_b = params.transformer) != null ? _b : noop;
  const schema = isStringLike ? internalSchema.transform(
    (val) => transformer(val)
  ) : internalSchema.transform(
    (val) => transformer(val)
  );
  return {
    rawSchema: rawSchema4,
    internalSchema,
    schema
  };
};
var createType = (params) => {
  const schemas4 = createSchema(params);
  const { parseErrMsg, unknownErrMsg } = params;
  const internalOf = (input) => {
    try {
      return (0, import_fluture2.resolve)(schemas4.schema.parse(input));
    } catch (previous) {
      const parseMsg = typeof parseErrMsg === "string" ? parseErrMsg : parseErrMsg(input, previous);
      const unknownMsg = typeof unknownErrMsg === "string" ? unknownErrMsg : unknownErrMsg(input);
      if (previous instanceof import_zod.ZodError) {
        return toFutureParseErr(previous, parseMsg, input);
      }
      return toFutureParseUnknownErr(previous, unknownMsg, input);
    }
  };
  const of3 = internalOf;
  const make3 = (input) => internalOf(input);
  const create4 = (input) => schemas4.schema.parse(input);
  const from = (input) => schemas4.schema.parse(input);
  const factory3 = {
    make: make3,
    of: of3,
    create: create4,
    from
  };
  return {
    schemas: schemas4,
    factory: factory3
  };
};
var Base_default = createType;

// out/types/NonEmptyString.ts
var import_fluture3 = require("fluture");
var import_zod3 = require("zod");

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

// out/types/NonEmptyString.ts
var schemas = {
  rawSchema: nonEmptyStringSchema,
  schema: nonEmptyStringSchema.transform((val) => val)
};
var rawSchema = schemas.rawSchema;

// SanitizedAbsPath.ts
var path = __toESM(require("path"));
var import_zod4 = require("zod");
var rawSchema2 = import_zod4.z.string({ description: "SanitizedAbsPath" }).min(1);
var { schemas: generatedSchemas, factory } = Base_default({
  isStringLike: true,
  rawSchema: rawSchema2,
  transformer: (value) => path.resolve(value),
  parseErrMsg: (value) => `${value} is an invalid absolute path`,
  unknownErrMsg: (value) => `Something went wrong trying to parse the absolute path, ${value}`
});
var { create: create2, make, of } = factory;
var schemas2 = {
  ...generatedSchemas,
  schema: generatedSchemas.schema.transform((val) => val)
};

// SanitizedArgs.ts
var import_zod5 = require("zod");
var rawSchema3 = import_zod5.z.object({
  _: import_zod5.z.array(import_zod5.z.union([import_zod5.z.string().min(1), import_zod5.z.number()])),
  projectDir: schemas2.schema,
  maxConcurrency: import_zod5.z.preprocess(
    (val) => typeof val === "string" ? parseInt(val) : Number(val),
    import_zod5.z.number().int().min(1).default(10)
  ),
  debug: import_zod5.z.preprocess(
    (val) => Boolean(val),
    import_zod5.z.boolean().default(false)
  ),
  disableState: import_zod5.z.preprocess(
    (val) => Boolean(val),
    import_zod5.z.boolean().default(false)
  ),
  logPluginRequests: import_zod5.z.preprocess(
    (val) => Boolean(val),
    import_zod5.z.boolean().default(false)
  ),
  fromVsCode: import_zod5.z.preprocess(
    (val) => Boolean(val),
    import_zod5.z.boolean().default(false)
  ),
  version: import_zod5.z.preprocess(
    (val) => Boolean(val),
    import_zod5.z.boolean().optional()
  ),
  build: import_zod5.z.preprocess(
    (val) => Boolean(val),
    import_zod5.z.boolean().optional()
  ),
  help: import_zod5.z.preprocess(
    (val) => Boolean(val),
    import_zod5.z.boolean().optional()
  ),
  yes: import_zod5.z.preprocess(
    (val) => Boolean(val),
    import_zod5.z.boolean().optional()
  ),
  plugin: schemas.schema.optional(),
  env: import_zod5.z.string().optional(),
  quickstart: import_zod5.z.string().min(1).optional(),
  setBuild: import_zod5.z.preprocess(
    (val) => String(val),
    import_zod5.z.string().min(3)
  ),
  setVersion: import_zod5.z.string().min(3),
  pluginName: import_zod5.z.string().min(1).optional()
}, { description: "Sanitizied Args" }).passthrough();
var scaffoldRawSchema = rawSchema3.extend({
  scaffoldProjectDir: import_zod5.z.string().min(1).transform((val) => val),
  scaffoldUrl: import_zod5.z.string().min(1).url().transform((val) => val),
  branch: import_zod5.z.string().min(1).optional()
});
var initRawSchema = rawSchema3.extend({
  workflow: import_zod5.z.string().refine((val) => val === "ligo" || val === "smartpy" || val === "archetype" || val === "michelson").optional()
});
var provisionRawSchema = rawSchema3.extend({
  operation: import_zod5.z.string().min(1).describe("Operation name"),
  name: import_zod5.z.string().min(1).regex(
    /^[a-z0-9]+[a-z0-9-_]$/,
    "Provisioner name must consist of one or more letters/numbers and may not start with an underscore or dash."
  ).describe("Provisioner name").optional()
}).passthrough();
var templateRawSchema = rawSchema3.extend({
  template: import_zod5.z.string().min(1)
}).passthrough();
var managePluginRawSchema = rawSchema3.omit({ pluginName: true }).extend({
  pluginName: import_zod5.z.string().min(1)
});
var setEnvRawSchema = rawSchema3.extend({
  defaultEnvironment: import_zod5.z.string().min(1)
});
var { schemas: generatedSchemas2, factory: factory2 } = Base_default({
  rawSchema: rawSchema3,
  parseErrMsg: "The arguments provided are invalid",
  unknownErrMsg: "Something went wrong parsing the command-line arguments"
});
var { create: create3, of: of2, make: make2 } = factory2;
var schemas3 = {
  ...generatedSchemas2,
  schema: generatedSchemas2.schema.transform((val) => val)
};
var scaffoldTaskArgs = Base_default({
  rawSchema: scaffoldRawSchema,
  parseErrMsg: "The arguments provided are invalid for the scaffold task",
  unknownErrMsg: "Something went wrong parsing the arguments for the scaffold task"
});
var provisionTaskArgs = Base_default({
  rawSchema: provisionRawSchema,
  parseErrMsg: "The arguments provided are invalid for the provision task",
  unknownErrMsg: "Something went wrong parsing the arguments for the provision task"
});
var installTaskArgs = Base_default({
  rawSchema: managePluginRawSchema,
  parseErrMsg: "The arguments provided are invalid for the install task",
  unknownErrMsg: "Something went wrong parsing the arguments for the install task"
});
var uninstallTaskArgs = Base_default({
  rawSchema: managePluginRawSchema,
  parseErrMsg: "The arguments provided are invalid for the uninstall task",
  unknownErrMsg: "Something went wrong parsing the arguments for the uninstall task"
});
var setEnvTaskArgs = Base_default({
  rawSchema: setEnvRawSchema,
  parseErrMsg: "The arguments provided are invalid for the set-environment task",
  unknownErrMsg: "Something went wrong parsing the arguments for the set-environment task"
});
var createTaskArgs = Base_default({
  rawSchema: templateRawSchema,
  parseErrMsg: "The arguments provided are invalid for the create task",
  unknownErrMsg: "Something went wrong parsing the arguments for the create task"
});
var createScaffoldTaskArgs = scaffoldTaskArgs.factory.from;
var makeScaffoldTaskArgs = scaffoldTaskArgs.factory.make;
var ofScaffoldTaskArgs = scaffoldTaskArgs.factory.of;
var createProvisionTaskArgs = provisionTaskArgs.factory.create;
var makeProvisionTaskArgs = provisionTaskArgs.factory.make;
var ofProvisionTaskArgs = provisionTaskArgs.factory.of;
var createInstallTaskArgs = installTaskArgs.factory.create;
var makeInstallTaskArgs = installTaskArgs.factory.make;
var ofInstallTaskArgs = installTaskArgs.factory.of;
var createUninstallTaskArgs = uninstallTaskArgs.factory.create;
var makeUninstallTaskArgs = uninstallTaskArgs.factory.make;
var ofUninstallTaskArgs = uninstallTaskArgs.factory.of;
var createSetEnvTaskArgs = setEnvTaskArgs.factory.create;
var makeSetEnvTaskArgs = setEnvTaskArgs.factory.make;
var ofSetEnvTaskArgs = setEnvTaskArgs.factory.of;
var createCreateTaskArgs = createTaskArgs.factory.create;
var makeCreateTaskArgs = createTaskArgs.factory.make;
var ofCreateTaskArgs = createTaskArgs.factory.of;
//# sourceMappingURL=SanitizedArgs.js.map