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

export interface CommandMismatch extends ValidationError.Proto {
  readonly _tag: "CommandMismatch"
  readonly error: HelpDoc
}

export interface CorrectedFlag extends ValidationError.Proto {
  readonly _tag: "CorrectedFlag"
  readonly error: HelpDoc
}

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

export interface InvalidArgument extends ValidationError.Proto {
  readonly _tag: "InvalidArgument"
  readonly error: HelpDoc
}

export interface InvalidValue extends ValidationError.Proto {
  readonly _tag: "InvalidValue"
  readonly error: HelpDoc
}

export interface MissingFlag extends ValidationError.Proto {
  readonly _tag: "MissingFlag"
  readonly error: HelpDoc
}

export interface MissingSubcommand extends ValidationError.Proto {
  readonly _tag: "MissingSubcommand"
  readonly error: HelpDoc
}

export interface MissingValue extends ValidationError.Proto {
  readonly _tag: "MissingValue"
  readonly error: HelpDoc
}

export interface MultipleValuesDetected extends ValidationError.Proto {
  readonly _tag: "MultipleValuesDetected"
  readonly error: HelpDoc
  readonly values: ReadonlyArray<string>
}

export interface NoBuiltInMatch extends ValidationError.Proto {
  readonly _tag: "NoBuiltInMatch"
  readonly error: HelpDoc
}

export interface UnclusteredFlag extends ValidationError.Proto {
  readonly _tag: "UnclusteredFlag"
  readonly error: HelpDoc
  readonly unclustered: ReadonlyArray<string>
  readonly rest: ReadonlyArray<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

export interface Proto {
  readonly [ValidationErrorTypeId]: ValidationErrorTypeId
}