@taqueria/protocol 0.14.4 → 0.18.0

package/SanitizedArgs.ts

@@ -1,213 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';
-import * as SanitizedAbsPath from '@taqueria/protocol/SanitizedAbsPath';
-import * as Url from '@taqueria/protocol/Url';
-import { z } from 'zod';
-
-export const rawSchema = z.object({
-	_: z.array(z.union([z.string().min(1), z.number()])),
-	projectDir: SanitizedAbsPath.schemas.schema,
-	maxConcurrency: z.preprocess(
-		val => typeof val === 'string' ? parseInt(val) : Number(val),
-		z.number().int().min(1).default(10),
-	),
-	debug: z.preprocess(
-		val => Boolean(val),
-		z.boolean().default(false),
-	),
-	disableState: z.preprocess(
-		val => Boolean(val),
-		z.boolean().default(false),
-	),
-	logPluginRequests: z.preprocess(
-		val => Boolean(val),
-		z.boolean().default(false),
-	),
-	fromVsCode: z.preprocess(
-		val => Boolean(val),
-		z.boolean().default(false),
-	),
-	version: z.preprocess(
-		val => Boolean(val),
-		z.boolean().optional(),
-	),
-	build: z.preprocess(
-		val => Boolean(val),
-		z.boolean().optional(),
-	),
-	help: z.preprocess(
-		val => Boolean(val),
-		z.boolean().optional(),
-	),
-	yes: z.preprocess(
-		val => Boolean(val),
-		z.boolean().optional(),
-	),
-	plugin: z.string().min(1).optional(),
-	env: z.union([z.literal('production'), z.literal('testing'), z.literal('development'), z.string().nonempty()])
-		.default('development'),
-	quickstart: z.string().min(1).optional(),
-	setBuild: z.preprocess(
-		val => String(val),
-		z.string().min(3),
-	),
-	setVersion: z.string().min(3),
-	pluginName: z.string().min(1).optional(),
-}, { description: 'Sanitizied Args' }).passthrough();
-
-export const scaffoldRawSchema = rawSchema.extend({
-	scaffoldProjectDir: z.string().min(1).transform((val: unknown) => val as SanitizedAbsPath.t),
-	scaffoldUrl: z.string().min(1).url().transform((val: unknown) => val as Url.t),
-});
-
-export const provisionRawSchema = rawSchema
-	.extend({
-		operation: z
-			.string()
-			.min(1)
-			.describe('Operation name'),
-		name: 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();
-
-export const templateRawSchema = rawSchema.extend({
-	template: z.string().min(1),
-}).passthrough();
-
-export const managePluginRawSchema = rawSchema.omit({ pluginName: true }).extend({
-	pluginName: z.string().min(1),
-});
-
-export const versionRawSchema = rawSchema.extend({
-	version: z.boolean().default(true),
-});
-
-export const addContractsRawSchema = z.preprocess(
-	val => {
-		const obj: {
-			contractName?: string;
-			sourceFile?: string;
-		} = typeof val === 'object' ? Object(val) : ({ contractName: '', sourceFile: '' });
-		return !obj.contractName && obj.sourceFile
-			? { ...obj, contractName: obj['sourceFile'] }
-			: obj;
-	},
-	rawSchema.extend({
-		sourceFile: z.string().min(1),
-		contractName: z.string().min(1),
-	}),
-);
-
-export const removeContractsRawSchema = rawSchema.extend({
-	contractName: z.string().min(1),
-});
-
-type RawInput = z.infer<typeof rawSchema>;
-type RawScaffoldInput = z.infer<typeof scaffoldRawSchema>;
-type RawProvisionInput = z.infer<typeof provisionRawSchema>;
-type RawManagePluginInput = z.infer<typeof managePluginRawSchema>;
-type RawVersionInput = z.infer<typeof versionRawSchema>;
-type RawTemplateInput = z.infer<typeof templateRawSchema>;
-type RawAddContractsInput = z.infer<typeof addContractsRawSchema>;
-type RawRemoveContractsInput = z.infer<typeof removeContractsRawSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
-	rawSchema,
-	parseErrMsg: 'The arguments provided are invalid',
-	unknownErrMsg: 'Something went wrong parsing the command-line arguments',
-});
-
-export const { create, of, make } = factory;
-
-export type SanitizedArgs = z.infer<typeof generatedSchemas.schema>;
-export type t = SanitizedArgs;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as SanitizedArgs),
-};
-
-export const scaffoldTaskArgs = createType<RawScaffoldInput, RawScaffoldInput>({
-	rawSchema: scaffoldRawSchema,
-	parseErrMsg: 'The arguments provided are invalid for the scaffold task',
-	unknownErrMsg: 'Something went wrong parsing the arguments for the scaffold task',
-});
-
-export const provisionTaskArgs = createType<RawProvisionInput, RawProvisionInput>({
-	rawSchema: provisionRawSchema,
-	parseErrMsg: 'The arguments provided are invalid for the provision task',
-	unknownErrMsg: 'Something went wrong parsing the arguments for the provision task',
-});
-
-export const installTaskArgs = createType<RawManagePluginInput, RawManagePluginInput>({
-	rawSchema: managePluginRawSchema,
-	parseErrMsg: 'The arguments provided are invalid for the install task',
-	unknownErrMsg: 'Something went wrong parsing the arguments for the install task',
-});
-
-export const uninstallTaskArgs = createType<RawManagePluginInput, RawManagePluginInput>({
-	rawSchema: managePluginRawSchema,
-	parseErrMsg: 'The arguments provided are invalid for the uninstall task',
-	unknownErrMsg: 'Something went wrong parsing the arguments for the uninstall task',
-});
-
-export const createTaskArgs = createType<RawTemplateInput, RawTemplateInput>({
-	rawSchema: templateRawSchema,
-	parseErrMsg: 'The arguments provided are invalid for the create task',
-	unknownErrMsg: 'Something went wrong parsing the arguments for the create task',
-});
-
-export const addContractArgs = createType<RawAddContractsInput, RawAddContractsInput>({
-	rawSchema: addContractsRawSchema,
-	parseErrMsg: 'Please specify the source file to register.',
-	unknownErrMsg: 'Something went wrong parsing the arguments for registering a contract.',
-});
-
-export const removeContractsArgs = createType<RawRemoveContractsInput, RawRemoveContractsInput>({
-	rawSchema: removeContractsRawSchema,
-	parseErrMsg: 'Please specify the contract name to unregister.',
-	unknownErrMsg: 'Something went wrong parsing the arguments to unregister a contract.',
-});
-
-export type ScaffoldTaskArgs = z.infer<typeof scaffoldTaskArgs.schemas.schema>;
-export type ProvisionTaskArgs = z.infer<typeof provisionTaskArgs.schemas.schema>;
-export type InstallTaskArgs = z.infer<typeof installTaskArgs.schemas.schema>;
-export type UninstallTaskArgs = z.infer<typeof uninstallTaskArgs.schemas.schema>;
-export type CreateTaskArgs = z.infer<typeof createTaskArgs.schemas.schema>;
-export type AddContractArgs = z.infer<typeof addContractArgs.schemas.schema>;
-export type RemoveContractArgs = z.infer<typeof removeContractsArgs.schemas.schema>;
-
-export const createScaffoldTaskArgs = scaffoldTaskArgs.factory.from;
-export const makeScaffoldTaskArgs = scaffoldTaskArgs.factory.make;
-export const ofScaffoldTaskArgs = scaffoldTaskArgs.factory.of;
-
-export const createProvisionTaskArgs = provisionTaskArgs.factory.create;
-export const makeProvisionTaskArgs = provisionTaskArgs.factory.make;
-export const ofProvisionTaskArgs = provisionTaskArgs.factory.of;
-
-export const createInstallTaskArgs = installTaskArgs.factory.create;
-export const makeInstallTaskArgs = installTaskArgs.factory.make;
-export const ofInstallTaskArgs = installTaskArgs.factory.of;
-
-export const createUninstallTaskArgs = uninstallTaskArgs.factory.create;
-export const makeUninstallTaskArgs = uninstallTaskArgs.factory.make;
-export const ofUninstallTaskArgs = uninstallTaskArgs.factory.of;
-
-export const createCreateTaskArgs = createTaskArgs.factory.create;
-export const makeCreateTaskArgs = createTaskArgs.factory.make;
-export const ofCreateTaskArgs = createTaskArgs.factory.of;
-export const createAddContractArgs = addContractArgs.factory.create;
-export const makeAddContractArgs = addContractArgs.factory.make;
-export const ofAddContractArgs = addContractArgs.factory.of;
-
-export const createRemoveContractsArgs = removeContractsArgs.factory.create;
-export const makeRemoveContractsArgs = removeContractsArgs.factory.make;
-export const ofRemoveContractsArgs = removeContractsArgs.factory.of;

package/SanitizedPath.ts

@@ -1,28 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z
-	.string({ description: 'Sanitized Path' })
-	.transform(value => {
-		const result = value.match(/^(\.\.|\.\/|\/)/);
-		return result ? value : `./${value}`;
-	});
-
-type RawInput = z.infer<typeof rawSchema>;
-
-const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
-	isStringLike: true,
-	rawSchema,
-	parseErrMsg: (value: unknown) => `${value} is an invalid filesystem path`,
-	unknownErrMsg: (value: unknown) => `Something went wrong trying to parse the filesystem path, ${value}`,
-});
-
-export const internalSchema = generatedSchemas.schema;
-
-export type SanitizedPath = z.infer<typeof internalSchema>;
-export type t = SanitizedPath;
-export const { create, of, make } = factory;
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as SanitizedPath),
-};

package/ScaffoldConfig.ts

@@ -1,6 +0,0 @@
-// TODO - use zod schema
-export interface ScaffoldType {
-	postInit?: string;
-}
-
-export type t = ScaffoldType;

package/Settings.ts

@@ -1,27 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z.object({
-	consent: z.union(
-		[z.literal('opt_in'), z.literal('opt_out')],
-		{ description: 'Consent' },
-	),
-}).describe('Setting');
-
-type RawInput = z.infer<typeof rawSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
-	rawSchema,
-	parseErrMsg: (value: unknown) => `${value} is not a valid settings type`,
-	unknownErrMsg: 'Something went wrong when parsing the settings file',
-});
-
-export type Settings = z.infer<typeof generatedSchemas.schema>;
-export type t = Settings;
-
-export const { create, of, make } = factory;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as Settings),
-};

package/SingleChar.ts

@@ -1,23 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z
-	.string({ description: 'Single character' })
-	.regex(/^[A-Za-z]$/, 'Must be a single character');
-
-type RawInput = z.infer<typeof rawSchema>;
-
-export const { factory, schemas: generatedSchemas } = createType<RawInput, RawInput>({
-	isStringLike: true,
-	rawSchema,
-	parseErrMsg: (value: unknown) => `${value} is not a single character`,
-	unknownErrMsg: `Something went wrong trying to parse a single character`,
-});
-
-export type SingleChar = z.infer<typeof generatedSchemas.schema>;
-export type t = SingleChar;
-export const { create, of, make } = factory;
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as SingleChar),
-};

package/TaqError.ts

@@ -1,78 +0,0 @@
-import { map, reject } from 'fluture';
-import { ZodError } from 'zod';
-
-export type ErrorType =
-	| 'E_INVALID_PATH_DOES_NOT_EXIST'
-	| 'E_INVALID_PATH_EXISTS_AND_NOT_AN_EMPTY_DIR'
-	| 'E_INVALID_PATH_ALREADY_EXISTS'
-	| 'E_INVALID_CONFIG'
-	| 'E_INVALID_JSON'
-	| 'E_FORK'
-	| 'E_INVALID_TASK'
-	| 'E_READFILE'
-	| 'E_NPM_INIT'
-	| 'E_INVALID_PLUGIN_RESPONSE'
-	| 'E_INVALID_ARGS'
-	| 'E_MKDIR_FAILED'
-	| 'E_GIT_CLONE_FAILED'
-	| 'E_PROVISION'
-	| 'E_PARSE'
-	| 'E_PARSE_UNKNOWN'
-	| 'E_INVALID_ARCH'
-	| 'E_CONTRACT_REGISTERED'
-	| 'E_CONTRACT_NOT_REGISTERED'
-	| 'E_NO_PROVISIONS'
-	| 'E_INTERNAL_LOGICAL_VALIDATION_FAILURE'
-	| 'E_EXEC';
-
-export interface TaqError {
-	readonly kind: ErrorType;
-	msg: string;
-	previous?: TaqError | Error | unknown;
-	context?: unknown;
-}
-
-export type t = TaqError;
-
-export class E_TaqError extends Error {
-	readonly context;
-	readonly kind;
-	readonly previous;
-	constructor(taqErr: TaqError) {
-		super(taqErr.msg);
-		this.context = taqErr.context;
-		this.kind = taqErr.kind;
-		this.name = this.kind;
-		this.previous = taqErr.previous;
-	}
-}
-
-export const toFutureParseErr = <T>(previous: ZodError, msg: string, context?: unknown) =>
-	reject(toParseErr(previous, msg, context))
-		.pipe(map((val: unknown) => val as T));
-
-export const toParseErr = (previous: ZodError, msg: string, context?: unknown) =>
-	create({
-		kind: 'E_PARSE',
-		msg: msg,
-		context,
-		previous,
-	});
-
-export const toParseUnknownErr = (previous: Error | TaqError | E_TaqError | unknown, msg: string, context?: unknown) =>
-	create({
-		kind: 'E_PARSE_UNKNOWN',
-		msg: msg,
-		context,
-		previous,
-	});
-
-export const toFutureParseUnknownErr = <T>(
-	previous: Error | TaqError | E_TaqError | unknown,
-	msg: string,
-	context?: unknown,
-) =>
-	reject(toParseUnknownErr(previous, msg, context))
-		.pipe(map((val: unknown) => val as T));
-
-export const create = (err: TaqError) => err;

package/Task.ts

@@ -1,57 +0,0 @@
-import * as Alias from '@taqueria/protocol/Alias';
-import createType, { Flatten } from '@taqueria/protocol/Base';
-import * as Command from '@taqueria/protocol/Command';
-import * as Option from '@taqueria/protocol/Option';
-import * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';
-import * as PositionalArg from '@taqueria/protocol/PositionalArg';
-import * as Verb from '@taqueria/protocol/Verb';
-import { z } from 'zod';
-
-const taskHandlerSchema = z.union([
-	z.literal('proxy'),
-	z.string().min(1),
-]);
-
-export const rawSchema = z.object({
-	task: Verb.rawSchema.describe('Task Name'),
-	command: Command.rawSchema.describe('Task Command'),
-	aliases: z.array(Alias.rawSchema).default([]).describe('Task Aliases').optional(),
-	description: z.string({ description: 'Task Description' }).min(3),
-	example: z.string({ description: 'Task Example' }).optional(),
-	hidden: z.boolean({ description: 'Task Is Hidden' }).default(false).optional(),
-	encoding: PluginResponseEncoding.rawSchema.optional(),
-	handler: taskHandlerSchema.describe('Task Handler'),
-	options: z.array(Option.rawSchema).default([]).describe('Task Options').optional(),
-	positionals: z.array(PositionalArg.rawSchema).default([]).describe('Task Positional Args').optional(),
-}).describe('Task');
-
-const internalSchema = rawSchema.extend({
-	task: Verb.schemas.schema.describe('Task Name'),
-	command: Command.schemas.schema.describe('Task Command'),
-	aliases: z.array(Alias.schemas.schema).default([]).describe('Task Aliases').optional(),
-	encoding: PluginResponseEncoding.schemas.schema.optional(),
-	handler: taskHandlerSchema.describe('Task Handler'),
-	options: z.preprocess(
-		val => val ?? [],
-		z.array(Option.schemas.schema).describe('Task Options').optional(),
-	),
-	positionals: z.array(PositionalArg.schemas.schema).default([]).describe('Task Positional Args').optional(),
-}).describe('Task');
-
-type RawInput = z.infer<typeof rawSchema>;
-type Input = z.infer<typeof internalSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
-	rawSchema,
-	internalSchema,
-	parseErrMsg: (value: unknown) => `The following task is invalid: ${value}`,
-	unknownErrMsg: 'Something went wrong trying to parse the task',
-});
-
-export type Task = z.infer<typeof generatedSchemas.schema>;
-export type t = Task;
-export const { create, make, of } = factory;
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as unknown as Task),
-};

package/Template.ts

@@ -1,77 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import * as Command from '@taqueria/protocol/Command';
-import * as Option from '@taqueria/protocol/Option';
-import * as PluginJsonResponse from '@taqueria/protocol/PluginJsonResponse';
-import * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';
-import * as PositionalArg from '@taqueria/protocol/PositionalArg';
-import * as RequestArgs from '@taqueria/protocol/RequestArgs';
-import * as Verb from '@taqueria/protocol/Verb';
-import { z } from 'zod';
-
-const handlerSchema = z.union([
-	z.string().min(1),
-	z.function().args(RequestArgs.schemas.schema).returns(z.union([
-		z.void(),
-		PluginJsonResponse.schemas.schema,
-		PluginJsonResponse.schemas.internalSchema,
-		z.promise(
-			z.union([
-				z.promise(z.void()),
-				z.void(),
-				PluginJsonResponse.schemas.schema,
-				PluginJsonResponse.schemas.internalSchema,
-			]),
-		),
-	])),
-]);
-
-export const rawSchema = z.object({
-	template: Verb.rawSchema,
-	command: Command.rawSchema,
-	description: z.string().min(4),
-	hidden: z.preprocess(
-		val => val ?? false,
-		z.boolean(),
-	).optional(),
-	options: z.preprocess(
-		val => val ?? [],
-		z.array(Option.rawSchema),
-	).optional(),
-	positionals: z.preprocess(
-		val => val ?? [],
-		z.array(PositionalArg.rawSchema),
-	).optional(),
-	handler: handlerSchema.describe('Template Handler'),
-	encoding: PluginResponseEncoding.schemas.schema.optional(),
-});
-
-export const internalSchema = rawSchema.extend({
-	template: Verb.schemas.schema,
-	command: Command.schemas.schema,
-	options: z.preprocess(
-		val => val ?? [],
-		z.array(Option.schemas.schema),
-	).optional(),
-	positionals: z.preprocess(
-		val => val ?? [],
-		z.array(PositionalArg.schemas.schema),
-	).optional(),
-});
-
-type RawInput = z.infer<typeof rawSchema>;
-type Input = z.infer<typeof internalSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
-	rawSchema,
-	internalSchema,
-	parseErrMsg: (value: unknown) => `The following template is invalid: ${value}`,
-	unknownErrMsg: 'Something went wrong trying to parse the template',
-});
-
-export type Template = z.infer<typeof generatedSchemas.schema>;
-export type t = Template;
-export const { create, make, of } = factory;
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as unknown as Template),
-};

package/Timestamp.ts

@@ -1,25 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z
-	.number({ description: 'Timestamp' })
-	.min(1651846877);
-
-type Input = z.infer<typeof rawSchema>;
-
-export const { factory, schemas: generatedSchemas } = createType<Input, Input>({
-	isStringLike: true,
-	rawSchema,
-	parseErrMsg: (value: unknown) => `${value} is an invalid timestamp`,
-	unknownErrMsg: `Something went wrong trying to parse a timestamp`,
-});
-
-export type Timestamp = z.infer<typeof generatedSchemas.schema>;
-export type t = Timestamp;
-export const { create, make, of } = factory;
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as Timestamp),
-};
-
-export const now = () => Date.now() as Timestamp;

package/Tz.ts

@@ -1,22 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z.string({ description: 'Tz' }).min(1).regex(/^\d([\d_]+\d)?$/);
-
-type RawInput = z.infer<typeof rawSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
-	isStringLike: true,
-	rawSchema,
-	parseErrMsg: (value: unknown) => `${value} is an invalid Tz amount`,
-	unknownErrMsg: 'Something went wrong when parsing the Tz amount',
-});
-
-export type Tz = z.infer<typeof generatedSchemas.schema>;
-
-export const { create, of, make } = factory;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as Tz),
-};

package/Url.ts

@@ -1,28 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z
-	.string({ description: 'Url' })
-	.url();
-
-type RawInput = z.infer<typeof rawSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
-	rawSchema,
-	isStringLike: true,
-	parseErrMsg: (value: unknown) => `${value} is an invalid url`,
-	unknownErrMsg: 'Something went wrong trying to parse the url',
-});
-
-export const toComponents = (url: Url) => {
-	const parts = new URL(url.toString());
-	return parts;
-};
-
-export type Url = z.infer<typeof generatedSchemas.schema>;
-export type t = Url;
-export const { create, of, make } = factory;
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as Url),
-};

package/Verb.ts

@@ -1,23 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z
-	.string({ description: 'Verb' })
-	.min(1, 'Must be a valid verb')
-	.regex(/^[A-Za-z\-\ ]+/, 'Must be a valid verb');
-
-type Input = z.infer<typeof rawSchema>;
-
-export const { factory, schemas: generatedSchemas } = createType<Input, Input>({
-	isStringLike: true,
-	rawSchema,
-	parseErrMsg: (value: unknown) => `${value} is not an invalid verb`,
-	unknownErrMsg: `Something went wrong trying to parse a verb`,
-});
-export type Verb = z.infer<typeof generatedSchemas.schema>;
-export type t = Verb;
-export const { create, make, of } = factory;
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as Verb),
-};

package/VersionNumber.ts

@@ -1,25 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z.string({ description: 'Version Number' })
-	.min(1)
-	.regex(/^\d+\.\d+(\.\d+)*$/);
-
-type RawInput = z.infer<typeof rawSchema>;
-
-const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
-	isStringLike: true,
-	rawSchema,
-	parseErrMsg: (value: unknown) => `${value} is an invalid version number`,
-	unknownErrMsg: 'Something went wrong trying to parse the version number',
-});
-
-export const internalSchema = generatedSchemas.schema;
-
-export type VersionNumber = z.infer<typeof internalSchema>;
-export type t = VersionNumber;
-export const { create, of, make } = factory;
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as VersionNumber),
-};