@taqueria/protocol
Version:
A TypeScript package which contains types that are to be shared between @taqueria/node-sdk and @taqueria/taqueria.
612 lines (600 loc) • 23.9 kB
JavaScript
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// ParsedPluginInfo.ts
var ParsedPluginInfo_exports = {};
__export(ParsedPluginInfo_exports, {
create: () => create3,
factory: () => factory2,
generatedSchemas: () => generatedSchemas,
make: () => make2,
of: () => of2,
rawSchema: () => rawSchema7,
schemas: () => schemas7
});
module.exports = __toCommonJS(ParsedPluginInfo_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: rawSchema8, isStringLike } = params;
const internalSchema3 = (_a = params.internalSchema) != null ? _a : params.rawSchema;
const noop = (val) => val;
const transformer = (_b = params.transformer) != null ? _b : noop;
const schema = isStringLike ? internalSchema3.transform(
(val) => transformer(val)
) : internalSchema3.transform(
(val) => transformer(val)
);
return {
rawSchema: rawSchema8,
internalSchema: internalSchema3,
schema
};
};
var createType = (params) => {
const schemas8 = createSchema(params);
const { parseErrMsg, unknownErrMsg } = params;
const internalOf = (input) => {
try {
return (0, import_fluture2.resolve)(schemas8.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) => schemas8.schema.parse(input);
const from = (input) => schemas8.schema.parse(input);
const factory3 = {
make: make3,
of: of3,
create: create4,
from
};
return {
schemas: schemas8,
factory: factory3
};
};
var Base_default = createType;
// out/types/ParsedOperation.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/ParsedOperation.ts
var schemas = {
rawSchema: parsedOperationSchema,
schema: parsedOperationSchema.transform((val) => val)
};
var rawSchema = schemas.rawSchema;
// out/types/Alias.ts
var import_fluture4 = require("fluture");
var import_zod4 = require("zod");
var schemas2 = {
rawSchema: aliasSchema,
schema: aliasSchema.transform((val) => val)
};
var rawSchema2 = schemas2.rawSchema;
// out/types/ParsedTemplate.ts
var import_fluture5 = require("fluture");
var import_zod5 = require("zod");
var schemas3 = {
rawSchema: parsedTemplateSchema,
schema: parsedTemplateSchema.transform((val) => val)
};
var rawSchema3 = schemas3.rawSchema;
// out/types/Task.ts
var import_fluture6 = require("fluture");
var import_zod6 = require("zod");
var schemas4 = {
rawSchema: taskSchema,
schema: taskSchema.transform((val) => val)
};
var rawSchema4 = schemas4.rawSchema;
// out/types/VersionNumber.ts
var import_fluture7 = require("fluture");
var import_zod7 = require("zod");
var schemas5 = {
rawSchema: versionNumberSchema,
schema: versionNumberSchema.transform((val) => val)
};
var rawSchema5 = schemas5.rawSchema;
// PluginInfo.ts
var import_zod8 = require("zod");
var rawSchema6 = import_zod8.z.object({
name: import_zod8.z.string({ description: "Plugin Name" }).min(1),
version: rawSchema5.describe("Plugin Version #"),
schema: rawSchema5.describe("Plugin Schema Version #"),
alias: rawSchema2.describe("Plugin Alias"),
postInstall: import_zod8.z.string().optional(),
tasks: import_zod8.z.preprocess(
(val) => val != null ? val : [],
import_zod8.z.array(
schemas4.schema.describe("Plugin Task"),
{ description: "Plugin Tasks" }
)
).optional(),
operations: import_zod8.z.preprocess(
(val) => val != null ? val : [],
import_zod8.z.array(
schemas.schema.describe("Plugin Operation"),
{ description: "Plugin Operations" }
)
).optional(),
templates: import_zod8.z.preprocess(
(val) => val != null ? val : [],
import_zod8.z.array(
schemas3.schema.describe("Plugin Template")
)
).optional()
});
var internalSchema = rawSchema6.extend({
version: schemas5.schema.describe("Plugin Version #"),
schema: schemas5.schema.describe("Plugin Schema Version #"),
alias: schemas2.schema.describe("Plugin Alias"),
tasks: import_zod8.z.preprocess(
(val) => val != null ? val : [],
import_zod8.z.array(
schemas4.schema.describe("Plugin Task"),
{ description: "Plugin Tasks" }
)
).optional(),
operations: import_zod8.z.preprocess(
(val) => val != null ? val : [],
import_zod8.z.array(
schemas.schema.describe("Plugin Operation"),
{ description: "Plugin Operations" }
)
).optional(),
templates: import_zod8.z.preprocess(
(val) => val != null ? val : [],
import_zod8.z.array(
schemas3.schema.describe("Plugin Template")
)
).optional()
}).describe("Plugin Schema");
var { schemas: schemas6, factory } = Base_default({
rawSchema: rawSchema6,
internalSchema,
parseErrMsg: "The schema returned from the plugin is invalid",
unknownErrMsg: "Something went wrong parsing the schema from a plugin"
});
var { create: create2, of, make } = factory;
// ParsedPluginInfo.ts
var import_zod9 = require("zod");
var internalSchema2 = internalSchema.extend({
operations: import_zod9.z.preprocess(
(val) => val != null ? val : [],
import_zod9.z.array(
schemas.schema,
{ description: "ParsedOperations" }
).optional()
)
}).describe("ParsedPluginInfo");
var rawSchema7 = internalSchema.extend({
operations: import_zod9.z.preprocess(
(val) => val != null ? val : [],
import_zod9.z.array(
rawSchema,
{ description: "ParsedOperation" }
)
).optional()
}).describe("ParsedPluginInfo");
var { schemas: generatedSchemas, factory: factory2 } = Base_default({
rawSchema: rawSchema7,
internalSchema: internalSchema2,
parseErrMsg: (value) => `The following plugin info gave us trouble when parsing the following plugin information: ${value}`,
unknownErrMsg: "Something went wrong trying to parse the plugin information"
});
var { create: create3, of: of2, make: make2 } = factory2;
var schemas7 = {
...generatedSchemas,
schema: generatedSchemas.schema.transform((val) => val)
};
//# sourceMappingURL=ParsedPluginInfo.js.map