@aussieljk/forkbook 0.0.1-4 → 0.0.1-6

package/dist/cli/index.d.ts

@@ -1,6 +1,7 @@
-import { bs as SupportedFramework$1, ds as StorybookConfigRaw$1, xs as SupportedBuilder$1, ys as SupportedRenderer$1 } from "../chunk-DIz17UEJ.js";
-import { t as JsPackageManager$1 } from "../chunk-B2t1tGRh.js";
+import { bs as SupportedFramework$1, ds as StorybookConfigRaw$1, xs as SupportedBuilder$1, ys as SupportedRenderer$1 } from "../chunk-CzmZhVrn.js";
+import { t as JsPackageManager$1 } from "../chunk-CYuvV2sR.js";
 import { Feature, SupportedBuilder, SupportedFramework, SupportedLanguage, SupportedRenderer } from "@aussieljk/forkbook/internal/types";
+import * as v from "valibot";
 import { JsPackageManager, PackageJson as PackageJson$1, PackageManagerName } from "@aussieljk/forkbook/internal/common";
 import { CsfValue } from "@aussieljk/forkbook/internal/csf-tools";
 
@@ -109,865 +110,11 @@ declare function configureEslintPlugin({
 }): Promise<void>;
 declare const suggestESLintPlugin: () => Promise<boolean>;
 //#endregion
-//#region ../../node_modules/zod/v3/helpers/typeAliases.d.cts
-type Primitive = string | number | symbol | bigint | boolean | null | undefined;
-//#endregion
-//#region ../../node_modules/zod/v3/helpers/util.d.cts
-declare namespace util {
-  type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2) ? true : false;
-  export type isAny<T> = 0 extends 1 & T ? true : false;
-  export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
-  export function assertIs<T>(_arg: T): void;
-  export function assertNever(_x: never): never;
-  export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-  export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
-  export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-  export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
-  export type InexactPartial<T> = { [k in keyof T]?: T[k] | undefined };
-  export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k };
-  export const getValidEnumValues: (obj: any) => any[];
-  export const objectValues: (obj: any) => any[];
-  export const objectKeys: ObjectConstructor["keys"];
-  export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
-  export type identity<T> = objectUtil.identity<T>;
-  export type flatten<T> = objectUtil.flatten<T>;
-  export type noUndefined<T> = T extends undefined ? never : T;
-  export const isInteger: NumberConstructor["isInteger"];
-  export function joinValues<T extends any[]>(array: T, separator?: string): string;
-  export const jsonStringifyReplacer: (_: string, value: any) => any;
-  export {};
-}
-declare namespace objectUtil {
-  export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : { [k in Exclude<keyof U, keyof V>]: U[k] } & V;
-  type optionalKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? k : never }[keyof T];
-  type requiredKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? never : k }[keyof T];
-  export type addQuestionMarks<T extends object, _O = any> = { [K in requiredKeys<T>]: T[K] } & { [K in optionalKeys<T>]?: T[K] } & { [k in keyof T]?: unknown };
-  export type identity<T> = T;
-  export type flatten<T> = identity<{ [k in keyof T]: T[k] }>;
-  export type noNeverKeys<T> = { [k in keyof T]: [T[k]] extends [never] ? never : k }[keyof T];
-  export type noNever<T> = identity<{ [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never }>;
-  export const mergeShapes: <U, T>(first: U, second: T) => T & U;
-  export type extendShape<A extends object, B extends object> = keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K] } & { [K in keyof B]: B[K] };
-  export {};
-}
-declare const ZodParsedType: {
-  string: "string";
-  nan: "nan";
-  number: "number";
-  integer: "integer";
-  float: "float";
-  boolean: "boolean";
-  date: "date";
-  bigint: "bigint";
-  symbol: "symbol";
-  function: "function";
-  undefined: "undefined";
-  null: "null";
-  array: "array";
-  object: "object";
-  unknown: "unknown";
-  promise: "promise";
-  void: "void";
-  never: "never";
-  map: "map";
-  set: "set";
-};
-type ZodParsedType = keyof typeof ZodParsedType;
-//#endregion
-//#region ../../node_modules/zod/v3/ZodError.d.cts
-type allKeys<T> = T extends any ? keyof T : never;
-type typeToFlattenedError<T, U = string> = {
-  formErrors: U[];
-  fieldErrors: { [P in allKeys<T>]?: U[] };
-};
-declare const ZodIssueCode: {
-  invalid_type: "invalid_type";
-  invalid_literal: "invalid_literal";
-  custom: "custom";
-  invalid_union: "invalid_union";
-  invalid_union_discriminator: "invalid_union_discriminator";
-  invalid_enum_value: "invalid_enum_value";
-  unrecognized_keys: "unrecognized_keys";
-  invalid_arguments: "invalid_arguments";
-  invalid_return_type: "invalid_return_type";
-  invalid_date: "invalid_date";
-  invalid_string: "invalid_string";
-  too_small: "too_small";
-  too_big: "too_big";
-  invalid_intersection_types: "invalid_intersection_types";
-  not_multiple_of: "not_multiple_of";
-  not_finite: "not_finite";
-};
-type ZodIssueCode = keyof typeof ZodIssueCode;
-type ZodIssueBase = {
-  path: (string | number)[];
-  message?: string | undefined;
-};
-interface ZodInvalidTypeIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.invalid_type;
-  expected: ZodParsedType;
-  received: ZodParsedType;
-}
-interface ZodInvalidLiteralIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.invalid_literal;
-  expected: unknown;
-  received: unknown;
-}
-interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.unrecognized_keys;
-  keys: string[];
-}
-interface ZodInvalidUnionIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.invalid_union;
-  unionErrors: ZodError[];
-}
-interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.invalid_union_discriminator;
-  options: Primitive[];
-}
-interface ZodInvalidEnumValueIssue extends ZodIssueBase {
-  received: string | number;
-  code: typeof ZodIssueCode.invalid_enum_value;
-  options: (string | number)[];
-}
-interface ZodInvalidArgumentsIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.invalid_arguments;
-  argumentsError: ZodError;
-}
-interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.invalid_return_type;
-  returnTypeError: ZodError;
-}
-interface ZodInvalidDateIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.invalid_date;
-}
-type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
-  includes: string;
-  position?: number | undefined;
-} | {
-  startsWith: string;
-} | {
-  endsWith: string;
-};
-interface ZodInvalidStringIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.invalid_string;
-  validation: StringValidation;
-}
-interface ZodTooSmallIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.too_small;
-  minimum: number | bigint;
-  inclusive: boolean;
-  exact?: boolean;
-  type: "array" | "string" | "number" | "set" | "date" | "bigint";
-}
-interface ZodTooBigIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.too_big;
-  maximum: number | bigint;
-  inclusive: boolean;
-  exact?: boolean;
-  type: "array" | "string" | "number" | "set" | "date" | "bigint";
-}
-interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.invalid_intersection_types;
-}
-interface ZodNotMultipleOfIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.not_multiple_of;
-  multipleOf: number | bigint;
-}
-interface ZodNotFiniteIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.not_finite;
-}
-interface ZodCustomIssue extends ZodIssueBase {
-  code: typeof ZodIssueCode.custom;
-  params?: {
-    [k: string]: any;
-  };
-}
-type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
-type ZodIssue = ZodIssueOptionalMessage & {
-  fatal?: boolean | undefined;
-  message: string;
-};
-type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? { [K in keyof T]?: ZodFormattedError<T[K]> } : T extends any[] ? {
-  [k: number]: ZodFormattedError<T[number]>;
-} : T extends object ? { [K in keyof T]?: ZodFormattedError<T[K]> } : unknown;
-type ZodFormattedError<T, U = string> = {
-  _errors: U[];
-} & recursiveZodFormattedError<NonNullable<T>>;
-declare class ZodError<T = any> extends Error {
-  issues: ZodIssue[];
-  get errors(): ZodIssue[];
-  constructor(issues: ZodIssue[]);
-  format(): ZodFormattedError<T>;
-  format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
-  static create: (issues: ZodIssue[]) => ZodError<any>;
-  static assert(value: unknown): asserts value is ZodError;
-  toString(): string;
-  get message(): string;
-  get isEmpty(): boolean;
-  addIssue: (sub: ZodIssue) => void;
-  addIssues: (subs?: ZodIssue[]) => void;
-  flatten(): typeToFlattenedError<T>;
-  flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
-  get formErrors(): typeToFlattenedError<T, string>;
-}
-type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
-type IssueData = stripPath<ZodIssueOptionalMessage> & {
-  path?: (string | number)[];
-  fatal?: boolean | undefined;
-};
-type ErrorMapCtx = {
-  defaultError: string;
-  data: any;
-};
-type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
-  message: string;
-};
-//#endregion
-//#region ../../node_modules/zod/v3/helpers/parseUtil.d.cts
-type ParseParams = {
-  path: (string | number)[];
-  errorMap: ZodErrorMap;
-  async: boolean;
-};
-type ParsePathComponent = string | number;
-type ParsePath = ParsePathComponent[];
-interface ParseContext {
-  readonly common: {
-    readonly issues: ZodIssue[];
-    readonly contextualErrorMap?: ZodErrorMap | undefined;
-    readonly async: boolean;
-  };
-  readonly path: ParsePath;
-  readonly schemaErrorMap?: ZodErrorMap | undefined;
-  readonly parent: ParseContext | null;
-  readonly data: any;
-  readonly parsedType: ZodParsedType;
-}
-type ParseInput = {
-  data: any;
-  path: (string | number)[];
-  parent: ParseContext;
-};
-declare class ParseStatus {
-  value: "aborted" | "dirty" | "valid";
-  dirty(): void;
-  abort(): void;
-  static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
-  static mergeObjectAsync(status: ParseStatus, pairs: {
-    key: ParseReturnType<any>;
-    value: ParseReturnType<any>;
-  }[]): Promise<SyncParseReturnType<any>>;
-  static mergeObjectSync(status: ParseStatus, pairs: {
-    key: SyncParseReturnType<any>;
-    value: SyncParseReturnType<any>;
-    alwaysSet?: boolean;
-  }[]): SyncParseReturnType;
-}
-type INVALID = {
-  status: "aborted";
-};
-declare const INVALID: INVALID;
-type DIRTY<T> = {
-  status: "dirty";
-  value: T;
-};
-declare const DIRTY: <T>(value: T) => DIRTY<T>;
-type OK<T> = {
-  status: "valid";
-  value: T;
-};
-declare const OK: <T>(value: T) => OK<T>;
-type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
-type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
-type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
-//#endregion
-//#region ../../node_modules/zod/v3/helpers/enumUtil.d.cts
-declare namespace enumUtil {
-  type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends ((k: infer Intersection) => void) ? Intersection : never;
-  type GetUnionLast<T> = UnionToIntersectionFn<T> extends (() => infer Last) ? Last : never;
-  type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;
-  type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;
-  export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
-  export {};
-}
-//#endregion
-//#region ../../node_modules/zod/v3/helpers/errorUtil.d.cts
-declare namespace errorUtil {
-  type ErrMessage = string | {
-    message?: string | undefined;
-  };
-  const errToObj: (message?: ErrMessage) => {
-    message?: string | undefined;
-  };
-  const toString: (message?: ErrMessage) => string | undefined;
-}
-//#endregion
-//#region ../../node_modules/zod/v3/helpers/partialUtil.d.cts
-declare namespace partialUtil {
-  type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{ [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>> }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? { [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
-}
-//#endregion
-//#region ../../node_modules/zod/v3/standard-schema.d.cts
-/**
- * The Standard Schema interface.
- */
-type StandardSchemaV1<Input = unknown, Output = Input> = {
-  /**
-   * The Standard Schema properties.
-   */
-  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-};
-declare namespace StandardSchemaV1 {
-  /**
-   * The Standard Schema properties interface.
-   */
-  export interface Props<Input = unknown, Output = Input> {
-    /**
-     * The version number of the standard.
-     */
-    readonly version: 1;
-    /**
-     * The vendor name of the schema library.
-     */
-    readonly vendor: string;
-    /**
-     * Validates unknown input values.
-     */
-    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-    /**
-     * Inferred types associated with the schema.
-     */
-    readonly types?: Types<Input, Output> | undefined;
-  }
-  /**
-   * The result interface of the validate function.
-   */
-  export type Result<Output> = SuccessResult<Output> | FailureResult;
-  /**
-   * The result interface if validation succeeds.
-   */
-  export interface SuccessResult<Output> {
-    /**
-     * The typed output value.
-     */
-    readonly value: Output;
-    /**
-     * The non-existent issues.
-     */
-    readonly issues?: undefined;
-  }
-  /**
-   * The result interface if validation fails.
-   */
-  export interface FailureResult {
-    /**
-     * The issues of failed validation.
-     */
-    readonly issues: ReadonlyArray<Issue>;
-  }
-  /**
-   * The issue interface of the failure output.
-   */
-  export interface Issue {
-    /**
-     * The error message of the issue.
-     */
-    readonly message: string;
-    /**
-     * The path of the issue, if any.
-     */
-    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-  }
-  /**
-   * The path segment interface of the issue.
-   */
-  export interface PathSegment {
-    /**
-     * The key representing a path segment.
-     */
-    readonly key: PropertyKey;
-  }
-  /**
-   * The Standard Schema types interface.
-   */
-  export interface Types<Input = unknown, Output = Input> {
-    /**
-     * The input type of the schema.
-     */
-    readonly input: Input;
-    /**
-     * The output type of the schema.
-     */
-    readonly output: Output;
-  }
-  /**
-   * Infers the input type of a Standard Schema.
-   */
-  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-  /**
-   * Infers the output type of a Standard Schema.
-   */
-  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-  export {};
-}
-//#endregion
-//#region ../../node_modules/zod/v3/types.d.cts
-interface RefinementCtx {
-  addIssue: (arg: IssueData) => void;
-  path: (string | number)[];
-}
-type ZodRawShape = {
-  [k: string]: ZodTypeAny;
-};
-type ZodTypeAny = ZodType<any, any, any>;
-type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
-type input<T extends ZodType<any, any, any>> = T["_input"];
-type output<T extends ZodType<any, any, any>> = T["_output"];
-type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
-interface ZodTypeDef {
-  errorMap?: ZodErrorMap | undefined;
-  description?: string | undefined;
-}
-type RawCreateParams = {
-  errorMap?: ZodErrorMap | undefined;
-  invalid_type_error?: string | undefined;
-  required_error?: string | undefined;
-  message?: string | undefined;
-  description?: string | undefined;
-} | undefined;
-type SafeParseSuccess<Output> = {
-  success: true;
-  data: Output;
-  error?: never;
-};
-type SafeParseError<Input> = {
-  success: false;
-  error: ZodError<Input>;
-  data?: never;
-};
-type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
-declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
-  readonly _type: Output;
-  readonly _output: Output;
-  readonly _input: Input;
-  readonly _def: Def;
-  get description(): string | undefined;
-  "~standard": StandardSchemaV1.Props<Input, Output>;
-  abstract _parse(input: ParseInput): ParseReturnType<Output>;
-  _getType(input: ParseInput): string;
-  _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
-  _processInputParams(input: ParseInput): {
-    status: ParseStatus;
-    ctx: ParseContext;
-  };
-  _parseSync(input: ParseInput): SyncParseReturnType<Output>;
-  _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
-  parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
-  safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
-  "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
-  parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
-  safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
-  /** Alias of safeParseAsync */
-  spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
-  refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
-  refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
-  refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
-  refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
-  _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
-  superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;
-  superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;
-  superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;
-  constructor(def: Def);
-  optional(): ZodOptional<this>;
-  nullable(): ZodNullable<this>;
-  nullish(): ZodOptional<ZodNullable<this>>;
-  array(): ZodArray<this>;
-  promise(): ZodPromise<this>;
-  or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
-  and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
-  transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
-  default(def: util.noUndefined<Input>): ZodDefault<this>;
-  default(def: () => util.noUndefined<Input>): ZodDefault<this>;
-  brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
-  catch(def: Output): ZodCatch<this>;
-  catch(def: (ctx: {
-    error: ZodError;
-    input: Input;
-  }) => Output): ZodCatch<this>;
-  describe(description: string): this;
-  pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
-  readonly(): ZodReadonly<this>;
-  isOptional(): boolean;
-  isNullable(): boolean;
-}
-type ZodNumberCheck = {
-  kind: "min";
-  value: number;
-  inclusive: boolean;
-  message?: string | undefined;
-} | {
-  kind: "max";
-  value: number;
-  inclusive: boolean;
-  message?: string | undefined;
-} | {
-  kind: "int";
-  message?: string | undefined;
-} | {
-  kind: "multipleOf";
-  value: number;
-  message?: string | undefined;
-} | {
-  kind: "finite";
-  message?: string | undefined;
-};
-interface ZodNumberDef extends ZodTypeDef {
-  checks: ZodNumberCheck[];
-  typeName: ZodFirstPartyTypeKind.ZodNumber;
-  coerce: boolean;
-}
-declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
-  _parse(input: ParseInput): ParseReturnType<number>;
-  static create: (params?: RawCreateParams & {
-    coerce?: boolean;
-  }) => ZodNumber;
-  gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-  min: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
-  gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-  lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-  max: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
-  lt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-  protected setLimit(kind: "min" | "max", value: number, inclusive: boolean, message?: string): ZodNumber;
-  _addCheck(check: ZodNumberCheck): ZodNumber;
-  int(message?: errorUtil.ErrMessage): ZodNumber;
-  positive(message?: errorUtil.ErrMessage): ZodNumber;
-  negative(message?: errorUtil.ErrMessage): ZodNumber;
-  nonpositive(message?: errorUtil.ErrMessage): ZodNumber;
-  nonnegative(message?: errorUtil.ErrMessage): ZodNumber;
-  multipleOf(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-  step: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
-  finite(message?: errorUtil.ErrMessage): ZodNumber;
-  safe(message?: errorUtil.ErrMessage): ZodNumber;
-  get minValue(): number | null;
-  get maxValue(): number | null;
-  get isInt(): boolean;
-  get isFinite(): boolean;
-}
-interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-  type: T;
-  typeName: ZodFirstPartyTypeKind.ZodArray;
-  exactLength: {
-    value: number;
-    message?: string | undefined;
-  } | null;
-  minLength: {
-    value: number;
-    message?: string | undefined;
-  } | null;
-  maxLength: {
-    value: number;
-    message?: string | undefined;
-  } | null;
-}
-type ArrayCardinality = "many" | "atleastone";
-type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
-declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  get element(): T;
-  min(minLength: number, message?: errorUtil.ErrMessage): this;
-  max(maxLength: number, message?: errorUtil.ErrMessage): this;
-  length(len: number, message?: errorUtil.ErrMessage): this;
-  nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
-  static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
-}
-type UnknownKeysParam = "passthrough" | "strict" | "strip";
-interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-  typeName: ZodFirstPartyTypeKind.ZodObject;
-  shape: () => T;
-  catchall: Catchall;
-  unknownKeys: UnknownKeys;
-}
-type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
-type baseObjectOutputType<Shape extends ZodRawShape> = { [k in keyof Shape]: Shape[k]["_output"] };
-type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
-type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{ [k in keyof Shape]: Shape[k]["_input"] }>;
-type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
-  [k: string]: T["_output"];
-};
-type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
-  [k: string]: T["_input"];
-};
-type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
-  [k: string]: unknown;
-} : unknown;
-type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
-declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
-  private _cached;
-  _getCached(): {
-    shape: T;
-    keys: string[];
-  };
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  get shape(): T;
-  strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall>;
-  strip(): ZodObject<T, "strip", Catchall>;
-  passthrough(): ZodObject<T, "passthrough", Catchall>;
-  /**
-   * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
-   * If you want to pass through unknown properties, use `.passthrough()` instead.
-   */
-  nonstrict: () => ZodObject<T, "passthrough", Catchall>;
-  extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
-  /**
-   * @deprecated Use `.extend` instead
-   *  */
-  augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
-  /**
-   * Prior to zod@1.0.12 there was a bug in the
-   * inferred type of merged objects. Please
-   * upgrade if you are experiencing issues.
-   */
-  merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
-  setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & { [k in Key]: Schema }, UnknownKeys, Catchall>;
-  catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
-  pick<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
-  omit<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
-  /**
-   * @deprecated
-   */
-  deepPartial(): partialUtil.DeepPartial<this>;
-  partial(): ZodObject<{ [k in keyof T]: ZodOptional<T[k]> }, UnknownKeys, Catchall>;
-  partial<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k] }>, UnknownKeys, Catchall>;
-  required(): ZodObject<{ [k in keyof T]: deoptional<T[k]> }, UnknownKeys, Catchall>;
-  required<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k] }>, UnknownKeys, Catchall>;
-  keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
-  static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
-  static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
-  static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
-}
-type AnyZodObject = ZodObject<any, any, any>;
-type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
-interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {
-  options: T;
-  typeName: ZodFirstPartyTypeKind.ZodUnion;
-}
-declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  get options(): T;
-  static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
-}
-interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-  left: T;
-  right: U;
-  typeName: ZodFirstPartyTypeKind.ZodIntersection;
-}
-declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
-}
-type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
-type AssertArray<T> = T extends any[] ? T : never;
-type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never }>;
-type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
-type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never }>;
-type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
-interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
-  items: T;
-  rest: Rest;
-  typeName: ZodFirstPartyTypeKind.ZodTuple;
-}
-declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  get items(): T;
-  rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
-  static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
-}
-type EnumValues<T extends string = string> = readonly [T, ...T[]];
-type Values<T extends EnumValues> = { [k in T[number]]: k };
-interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
-  values: T;
-  typeName: ZodFirstPartyTypeKind.ZodEnum;
-}
-type Writeable<T> = { -readonly [P in keyof T]: T[P] };
-type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
-type typecast<A, T> = A extends T ? A : never;
-declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
-declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
-declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
-  _cache: Set<T[number]> | undefined;
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  get options(): T;
-  get enum(): Values<T>;
-  get Values(): Values<T>;
-  get Enum(): Values<T>;
-  extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract, newDef?: RawCreateParams): ZodEnum<Writeable<ToExtract>>;
-  exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude, newDef?: RawCreateParams): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
-  static create: typeof createZodEnum;
-}
-interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-  type: T;
-  typeName: ZodFirstPartyTypeKind.ZodPromise;
-}
-declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
-  unwrap(): T;
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
-}
-type RefinementEffect<T> = {
-  type: "refinement";
-  refinement: (arg: T, ctx: RefinementCtx) => any;
-};
-type TransformEffect<T> = {
-  type: "transform";
-  transform: (arg: T, ctx: RefinementCtx) => any;
-};
-type PreprocessEffect<T> = {
-  type: "preprocess";
-  transform: (arg: T, ctx: RefinementCtx) => any;
-};
-type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
-interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-  schema: T;
-  typeName: ZodFirstPartyTypeKind.ZodEffects;
-  effect: Effect<any>;
-}
-declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {
-  innerType(): T;
-  sourceType(): T;
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
-  static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
-}
-interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-  innerType: T;
-  typeName: ZodFirstPartyTypeKind.ZodOptional;
-}
-declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  unwrap(): T;
-  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
-}
-interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-  innerType: T;
-  typeName: ZodFirstPartyTypeKind.ZodNullable;
-}
-declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  unwrap(): T;
-  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
-}
-interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-  innerType: T;
-  defaultValue: () => util.noUndefined<T["_input"]>;
-  typeName: ZodFirstPartyTypeKind.ZodDefault;
-}
-declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  removeDefault(): T;
-  static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
-    default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
-  }) => ZodDefault<Inner>;
-}
-interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-  innerType: T;
-  catchValue: (ctx: {
-    error: ZodError;
-    input: unknown;
-  }) => T["_input"];
-  typeName: ZodFirstPartyTypeKind.ZodCatch;
-}
-declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  removeCatch(): T;
-  static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
-    catch: Inner["_output"] | (() => Inner["_output"]);
-  }) => ZodCatch<Inner>;
-}
-interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
-  type: T;
-  typeName: ZodFirstPartyTypeKind.ZodBranded;
-}
-declare const BRAND: unique symbol;
-type BRAND<T extends string | number | symbol> = {
-  [BRAND]: { [k in T]: true };
-};
-declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
-  _parse(input: ParseInput): ParseReturnType<any>;
-  unwrap(): T;
-}
-interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {
-  in: A;
-  out: B;
-  typeName: ZodFirstPartyTypeKind.ZodPipeline;
-}
-declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
-  _parse(input: ParseInput): ParseReturnType<any>;
-  static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
-}
-type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
-  readonly [Symbol.toStringTag]: string;
-} | Date | Error | Generator | Promise<unknown> | RegExp;
-type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
-interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-  innerType: T;
-  typeName: ZodFirstPartyTypeKind.ZodReadonly;
-}
-declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
-  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
-  unwrap(): T;
-}
-declare enum ZodFirstPartyTypeKind {
-  ZodString = "ZodString",
-  ZodNumber = "ZodNumber",
-  ZodNaN = "ZodNaN",
-  ZodBigInt = "ZodBigInt",
-  ZodBoolean = "ZodBoolean",
-  ZodDate = "ZodDate",
-  ZodSymbol = "ZodSymbol",
-  ZodUndefined = "ZodUndefined",
-  ZodNull = "ZodNull",
-  ZodAny = "ZodAny",
-  ZodUnknown = "ZodUnknown",
-  ZodNever = "ZodNever",
-  ZodVoid = "ZodVoid",
-  ZodArray = "ZodArray",
-  ZodObject = "ZodObject",
-  ZodUnion = "ZodUnion",
-  ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
-  ZodIntersection = "ZodIntersection",
-  ZodTuple = "ZodTuple",
-  ZodRecord = "ZodRecord",
-  ZodMap = "ZodMap",
-  ZodSet = "ZodSet",
-  ZodFunction = "ZodFunction",
-  ZodLazy = "ZodLazy",
-  ZodLiteral = "ZodLiteral",
-  ZodEnum = "ZodEnum",
-  ZodEffects = "ZodEffects",
-  ZodNativeEnum = "ZodNativeEnum",
-  ZodOptional = "ZodOptional",
-  ZodNullable = "ZodNullable",
-  ZodDefault = "ZodDefault",
-  ZodCatch = "ZodCatch",
-  ZodPromise = "ZodPromise",
-  ZodBranded = "ZodBranded",
-  ZodPipeline = "ZodPipeline",
-  ZodReadonly = "ZodReadonly"
-}
-//#endregion
 //#region .dts-emit/code/core/src/cli/globalSettings.d.ts
-declare const userSettingSchema: ZodObject<{
-  version: ZodNumber;
-  userSince: ZodOptional<ZodNumber>;
-}, "strip", ZodTypeAny, {
-  version: number;
-  userSince?: number | undefined;
-}, {
-  version: number;
-  userSince?: number | undefined;
-}>;
+declare const userSettingSchema: v.ObjectSchema<{
+  readonly version: v.NumberSchema<undefined>;
+  readonly userSince: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>;
 declare function globalSettings(filePath?: string): Promise<Settings>;
 declare function _clearGlobalSettings(): void;
 /**
@@ -976,20 +123,20 @@ declare function _clearGlobalSettings(): void;
  */
 declare class Settings {
   private filePath;
-  value: TypeOf<typeof userSettingSchema>;
+  value: v.InferOutput<typeof userSettingSchema>;
   /**
    * Create a new Settings instance
    *
    * @param filePath Path to the JSON settings file
    * @param value Loaded value of settings
    */
-  constructor(filePath: string, value: TypeOf<typeof userSettingSchema>);
+  constructor(filePath: string, value: v.InferOutput<typeof userSettingSchema>);
   /** Save settings to the file */
   save(): Promise<void>;
 }
 //#endregion
 //#region .dts-emit/code/core/src/cli/AddonVitestService.d.ts
-type Result$1 = {
+type Result = {
   compatible: boolean;
   reasons?: string[];
 };
@@ -1072,18 +219,18 @@ declare class AddonVitestService {
    * - Next.js installation (if using @storybook/nextjs)
    * - Vitest config files (if configDir provided)
    */
-  validateCompatibility(options: AddonVitestCompatibilityOptions): Promise<Result$1>;
+  validateCompatibility(options: AddonVitestCompatibilityOptions): Promise<Result>;
   /**
    * Validate package versions for addon-vitest compatibility Public method to allow early
    * validation before framework detection
    */
-  validatePackageVersions(): Promise<Result$1>;
+  validatePackageVersions(): Promise<Result>;
   /**
    * Validate vitest config files for addon compatibility
    *
    * Public method that can be used by both postinstall and @aussieljk/forkbook/internal/create flows
    */
-  validateConfigFiles(directory: string): Promise<Result$1>;
+  validateConfigFiles(directory: string): Promise<Result>;
 }
 //#endregion
 //#region .dts-emit/code/core/src/cli/installSkills.d.ts