ValidationError

declare const commandMismatch: (error: HelpDoc) => ValidationError;

declare const correctedFlag: (error: HelpDoc) => ValidationError;

declare const helpRequested: <A>(command: Command<A>) => ValidationError;

declare const invalidArgument: (error: HelpDoc) => ValidationError;

declare const invalidValue: (error: HelpDoc) => ValidationError;

declare const keyValuesDetected: (
  error: HelpDoc,
  keyValues: ReadonlyArray<string>,
) => ValidationError;

declare const missingFlag: (error: HelpDoc) => ValidationError;

declare const missingSubcommand: (error: HelpDoc) => ValidationError;

declare const missingValue: (error: HelpDoc) => ValidationError;

declare const noBuiltInMatch: (error: HelpDoc) => ValidationError;

declare const unclusteredFlag: (
  error: HelpDoc,
  unclustered: ReadonlyArray<string>,
  rest: ReadonlyArray<string>,
) => ValidationError;

interface CommandMismatch extends Proto {
  readonly _tag: "CommandMismatch";
  readonly error: HelpDoc;
}

interface CorrectedFlag extends Proto {
  readonly _tag: "CorrectedFlag";
  readonly error: HelpDoc;
}

interface HelpRequested extends Proto {
  readonly _tag: "HelpRequested";
  readonly command: Command<unknown>;
  readonly error: HelpDoc;
}

interface InvalidArgument extends Proto {
  readonly _tag: "InvalidArgument";
  readonly error: HelpDoc;
}

interface InvalidValue extends Proto {
  readonly _tag: "InvalidValue";
  readonly error: HelpDoc;
}

interface MissingFlag extends Proto {
  readonly _tag: "MissingFlag";
  readonly error: HelpDoc;
}

interface MissingSubcommand extends Proto {
  readonly _tag: "MissingSubcommand";
  readonly error: HelpDoc;
}

interface MissingValue extends Proto {
  readonly _tag: "MissingValue";
  readonly error: HelpDoc;
}

interface MultipleValuesDetected extends Proto {
  readonly _tag: "MultipleValuesDetected";
  readonly error: HelpDoc;
  readonly values: readonly Array<string>;
}

interface NoBuiltInMatch extends Proto {
  readonly _tag: "NoBuiltInMatch";
  readonly error: HelpDoc;
}

interface UnclusteredFlag extends Proto {
  readonly _tag: "UnclusteredFlag";
  readonly error: HelpDoc;
  readonly rest: readonly Array<string>;
  readonly unclustered: readonly Array<string>;
}

type ValidationError =
  | CommandMismatch
  | CorrectedFlag
  | HelpRequested
  | InvalidArgument
  | InvalidValue
  | MissingValue
  | MissingFlag
  | MultipleValuesDetected
  | MissingSubcommand
  | NoBuiltInMatch
  | UnclusteredFlag;

declare const isCommandMismatch: (self: ValidationError) => self is CommandMismatch;

declare const isCorrectedFlag: (self: ValidationError) => self is CorrectedFlag;

declare const isHelpRequested: (self: ValidationError) => self is HelpRequested;

declare const isInvalidArgument: (self: ValidationError) => self is InvalidArgument;

declare const isInvalidValue: (self: ValidationError) => self is InvalidValue;

declare const isMissingFlag: (self: ValidationError) => self is MissingFlag;

declare const isMissingSubcommand: (self: ValidationError) => self is MissingSubcommand;

declare const isMissingValue: (self: ValidationError) => self is MissingValue;

declare const isMultipleValuesDetected: (self: ValidationError) => self is MultipleValuesDetected;

declare const isNoBuiltInMatch: (self: ValidationError) => self is NoBuiltInMatch;

declare const isUnclusteredFlag: (self: ValidationError) => self is UnclusteredFlag;

declare const isValidationError: (u: unknown) => u is ValidationError;

declare const ValidationErrorTypeId: unique symbol;

type ValidationErrorTypeId = typeof ValidationErrorTypeId;