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