Param Docs

Base.ArgParserResult := [ShowHelp({ subcommand_path : List(Str) }), ShowVersion, IncorrectUsage(ArgExtractErr, { subcommand_path : List(Str) }), SuccessfullyParsed(a)]

Base.ArgParserResult.is_eq : _

Base.ArgParserParams : { args : List(ParsedArg), subcommand_path : List(Str) }

Base.ArgParserState : { data : a, remaining_args : List(ParsedArg), subcommand_path : List(Str) }

Base.ArgParser : ArgParserParams -> ArgParserResult(ArgParserState(a))

Base.ArgExtractErr : [NoSubcommandCalled, MissingOption(OptionConfig), OptionCanOnlyBeSetOnce(OptionConfig), NoValueProvidedForOption(OptionConfig), OptionDoesNotExpectValue(OptionConfig), CannotUsePartialShortGroupAsValue(OptionConfig, List(Str)), ValueOptionMustBeLastInShortGroup(OptionConfig, List(Str)), InvalidOptionValue(InvalidValue, OptionConfig), InvalidParamValue(InvalidValue, ParameterConfig), MissingParam(ParameterConfig), UnrecognizedSubcommand(Path), UnrecognizedShortArg(Str), UnrecognizedLongArg(Str), ExtraParamProvided(Path)]

Base.TextStyle : [Color, Plain]

Base.ExpectedValue : [ExpectsValue(Str), NothingExpected]

Base.Plurality : [Optional, One, Many]

Base.SpecialFlags : { help : Bool, version : Bool }

Base.InvalidValue : [InvalidNumStr, InvalidValue(Str), InvalidUtf8]

Base.DefaultValue : [NoDefault, Value(a), Generate({ } -> a)]

Base.ValueParser : Path -> Try(a, InvalidValue)

Base.OptionConfigBaseParams : { short : Str, long : Str, help : Str }

Base.DefaultableOptionConfigBaseParams : { short : Str, long : Str, help : Str, default : DefaultValue(a) }

Base.OptionConfigParams : { short : Str, long : Str, help : Str, type : Str, parser : ValueParser(a) }

Base.DefaultableOptionConfigParams : { short : Str, long : Str, help : Str, type : Str, parser : ValueParser(a), default : DefaultValue(a) }

Base.OptionConfig : { expected_value : ExpectedValue, plurality : Plurality, required : Bool, short : Str, long : Str, help : Str }

Base.ParameterConfigBaseParams : { name : Str, help : Str }

Base.DefaultableParameterConfigBaseParams : { name : Str, help : Str, default : DefaultValue(a) }

Base.ParameterConfigParams : { name : Str, help : Str, type : Str, parser : ValueParser(a) }

Base.DefaultableParameterConfigParams : { name : Str, help : Str, type : Str, parser : ValueParser(a), default : DefaultValue(a) }

Base.ParameterConfig : { name : Str, help : Str, type : Str, plurality : Plurality, required : Bool }

Base.CliConfigParams : { name : Str, authors : List(Str), version : Str, description : Str, text_style : TextStyle }

Base.CliConfig : { name : Str, authors : List(Str), version : Str, description : Str, subcommands : SubcommandsConfig, options : List(OptionConfig), parameters : List(ParameterConfig) }

Base.SubcommandConfigParams : { name : Str, description : Str }

Base.SubcommandConfig : { description : Str, options : List(OptionConfig), parameters : List(ParameterConfig), subcommands : SubcommandsConfig }

Base.SubcommandsConfig := [NoSubcommands, HasSubcommands({ commands : List((Str, SubcommandConfig)), required : Bool })]

Builder.from_arg_parser : (List(ParsedArg) -> Try({ data : data, remaining_args : List(ParsedArg) }, ArgExtractErr)) -> CliBuilder(data, from_action, to_action)

Builder.from_full_parser : ArgParser(data) -> CliBuilder(data, from_action, to_action)

Builder.add_option : CliBuilder(state, from_action, to_action), OptionConfig -> CliBuilder(state, from_action, to_action)

Builder.add_parameter : CliBuilder(state, from_action, to_action), ParameterConfig -> CliBuilder(state, from_action, to_action)

Builder.add_subcommands : CliBuilder(state, from_action, to_action), SubcommandsConfig -> CliBuilder(state, from_action, to_action)

Builder.set_parser : CliBuilder(state, from_action, to_action), ArgParser(next_state) -> CliBuilder(next_state, from_action, to_action)

Builder.update_parser : CliBuilder(state, from_action, to_action), ({ data : state, remaining_args : List(ParsedArg) } -> Try({ data : next_state, remaining_args : List(ParsedArg) }, ArgExtractErr)) -> CliBuilder(next_state, from_action, to_action)

Builder.bind_parser : CliBuilder(state, from_action, to_action), (ArgParserState(state) -> ArgParserResult(ArgParserState(next_state))) -> CliBuilder(next_state, from_action, to_action)

Builder.into_parts : CliBuilder(state, from_action, to_action) -> { parser : ArgParser(state), options : List(OptionConfig), parameters : List(ParameterConfig), subcommands : SubcommandsConfig }

Builder.map : CliBuilder(a, from_action, to_action), (a -> b) -> CliBuilder(b, from_action, to_action)

Builder.combine : CliBuilder(a, action1, action2), CliBuilder(b, action2, action3), (a, b -> c) -> CliBuilder(c, action1, action3)

Builder.flag_was_passed : OptionConfig, List(ParsedArg) -> Bool

Builder.check_for_help_and_version : CliBuilder(state, from_action, to_action) -> CliBuilder(state, from_action, to_action)

Builder.GetOptionsAction : { get_options : { } }

Builder.GetParamsAction : { get_params : { } }

Builder.StopCollectingAction : []

Builder.CliBuilder : Builder(data, from_action, to_action)

Cli.map : CliBuilder(a, from_action, to_action), (a -> b) -> CliBuilder(b, from_action, to_action)

Cli.map2 : CliBuilder(a, action1, action2), CliBuilder(b, action2, action3), (a, b -> c) -> CliBuilder(c, action1, action3)

Cli.weave : CliBuilder(a, action1, action2), CliBuilder(b, action2, action3), (a, b -> c) -> CliBuilder(c, action1, action3)

Cli.ensure_all_args_were_parsed : List(ParsedArg) -> Try({ }, ArgExtractErr)

Cli.finish : CliBuilder(data, from_action, to_action), CliConfigParams -> Try(CliParser(data), CliValidationErr)

Cli.finish_without_validating : CliBuilder(data, from_action, to_action), CliConfigParams -> CliParser(data)

Cli.assert_valid : Try(CliParser(data), CliValidationErr) -> CliParser(data)

Cli.parse_or_display_message : CliParser(data), List(arg), (arg -> [Utf8(Str), UnixBytes(List(U8)), WindowsU16s(List(U16))]) -> Try(data, [Help(Str), Version(Str), InvalidUsage(Str)])

Cli.CliParser : { config : CliConfig, parser : List(Path) -> ArgParserResult(state), text_style : TextStyle }

ErrorFormatter.format_arg_extract_err : ArgExtractErr -> Str

ErrorFormatter.render_arg_extract_err : ArgExtractErr, { command : Str, usage : Str }, TextStyle -> Str

ErrorFormatter.format_cli_validation_err : CliValidationErr -> Str

ErrorFormatter.render_cli_validation_err : CliValidationErr, TextStyle -> Str

Help.find_subcommand_or_default : CliConfig, List(Str) -> { config : CliConfig, subcommand_path : List(Str) }

Help.find_subcommand : SubcommandConfig, List(Str) -> Try(SubcommandConfig, [KeyNotFound])

Help.help_text : CliConfig, List(Str), TextStyle -> Str

Help.usage_help : CliConfig, List(Str), TextStyle -> Str

Opt.builder_with_option_parser : OptionConfig, (List(ArgValue) -> Try(data, ArgExtractErr)) -> CliBuilder(data, GetOptionsAction, GetOptionsAction)

Opt.get_maybe_value : List(ArgValue), OptionConfig -> Try(Try(ArgValue, [NoValue]), ArgExtractErr)

Opt.single : DefaultableOptionConfigParams(a) -> CliBuilder(a, GetOptionsAction, GetOptionsAction)

Opt.maybe : OptionConfigParams(data) -> CliBuilder(Try(data, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.list : OptionConfigParams(data) -> CliBuilder(List(data), GetOptionsAction, GetOptionsAction)

Opt.flag : OptionConfigBaseParams -> CliBuilder(Bool, GetOptionsAction, GetOptionsAction)

Opt.count : OptionConfigBaseParams -> CliBuilder(U64, GetOptionsAction, GetOptionsAction)

Opt.arg : DefaultableOptionConfigBaseParams(Path) -> CliBuilder(Path, GetOptionsAction, GetOptionsAction)

Opt.maybe_arg : OptionConfigBaseParams -> CliBuilder(Try(Path, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.arg_list : OptionConfigBaseParams -> CliBuilder(List(Path), GetOptionsAction, GetOptionsAction)

Opt.bytes : DefaultableOptionConfigBaseParams(List(U8)) -> CliBuilder(List(U8), GetOptionsAction, GetOptionsAction)

Opt.maybe_bytes : OptionConfigBaseParams -> CliBuilder(Try(List(U8), [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.bytes_list : OptionConfigBaseParams -> CliBuilder(List(List(U8)), GetOptionsAction, GetOptionsAction)

Opt.str : DefaultableOptionConfigBaseParams(Str) -> CliBuilder(Str, GetOptionsAction, GetOptionsAction)

Opt.maybe_str : OptionConfigBaseParams -> CliBuilder(Try(Str, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.str_list : OptionConfigBaseParams -> CliBuilder(List(Str), GetOptionsAction, GetOptionsAction)

Opt.dec : DefaultableOptionConfigBaseParams(Dec) -> CliBuilder(Dec, GetOptionsAction, GetOptionsAction)

Opt.maybe_dec : OptionConfigBaseParams -> CliBuilder(Try(Dec, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.dec_list : OptionConfigBaseParams -> CliBuilder(List(Dec), GetOptionsAction, GetOptionsAction)

Opt.f32 : DefaultableOptionConfigBaseParams(F32) -> CliBuilder(F32, GetOptionsAction, GetOptionsAction)

Opt.maybe_f32 : OptionConfigBaseParams -> CliBuilder(Try(F32, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.f32_list : OptionConfigBaseParams -> CliBuilder(List(F32), GetOptionsAction, GetOptionsAction)

Opt.f64 : DefaultableOptionConfigBaseParams(F64) -> CliBuilder(F64, GetOptionsAction, GetOptionsAction)

Opt.maybe_f64 : OptionConfigBaseParams -> CliBuilder(Try(F64, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.f64_list : OptionConfigBaseParams -> CliBuilder(List(F64), GetOptionsAction, GetOptionsAction)

Opt.u8 : DefaultableOptionConfigBaseParams(U8) -> CliBuilder(U8, GetOptionsAction, GetOptionsAction)

Opt.maybe_u8 : OptionConfigBaseParams -> CliBuilder(Try(U8, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.u8_list : OptionConfigBaseParams -> CliBuilder(List(U8), GetOptionsAction, GetOptionsAction)

Opt.u16 : DefaultableOptionConfigBaseParams(U16) -> CliBuilder(U16, GetOptionsAction, GetOptionsAction)

Opt.maybe_u16 : OptionConfigBaseParams -> CliBuilder(Try(U16, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.u16_list : OptionConfigBaseParams -> CliBuilder(List(U16), GetOptionsAction, GetOptionsAction)

Opt.u32 : DefaultableOptionConfigBaseParams(U32) -> CliBuilder(U32, GetOptionsAction, GetOptionsAction)

Opt.maybe_u32 : OptionConfigBaseParams -> CliBuilder(Try(U32, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.u32_list : OptionConfigBaseParams -> CliBuilder(List(U32), GetOptionsAction, GetOptionsAction)

Opt.u64 : DefaultableOptionConfigBaseParams(U64) -> CliBuilder(U64, GetOptionsAction, GetOptionsAction)

Opt.maybe_u64 : OptionConfigBaseParams -> CliBuilder(Try(U64, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.u64_list : OptionConfigBaseParams -> CliBuilder(List(U64), GetOptionsAction, GetOptionsAction)

Opt.u128 : DefaultableOptionConfigBaseParams(U128) -> CliBuilder(U128, GetOptionsAction, GetOptionsAction)

Opt.maybe_u128 : OptionConfigBaseParams -> CliBuilder(Try(U128, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.u128_list : OptionConfigBaseParams -> CliBuilder(List(U128), GetOptionsAction, GetOptionsAction)

Opt.i8 : DefaultableOptionConfigBaseParams(I8) -> CliBuilder(I8, GetOptionsAction, GetOptionsAction)

Opt.maybe_i8 : OptionConfigBaseParams -> CliBuilder(Try(I8, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.i8_list : OptionConfigBaseParams -> CliBuilder(List(I8), GetOptionsAction, GetOptionsAction)

Opt.i16 : DefaultableOptionConfigBaseParams(I16) -> CliBuilder(I16, GetOptionsAction, GetOptionsAction)

Opt.maybe_i16 : OptionConfigBaseParams -> CliBuilder(Try(I16, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.i16_list : OptionConfigBaseParams -> CliBuilder(List(I16), GetOptionsAction, GetOptionsAction)

Opt.i32 : DefaultableOptionConfigBaseParams(I32) -> CliBuilder(I32, GetOptionsAction, GetOptionsAction)

Opt.maybe_i32 : OptionConfigBaseParams -> CliBuilder(Try(I32, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.i32_list : OptionConfigBaseParams -> CliBuilder(List(I32), GetOptionsAction, GetOptionsAction)

Opt.i64 : DefaultableOptionConfigBaseParams(I64) -> CliBuilder(I64, GetOptionsAction, GetOptionsAction)

Opt.maybe_i64 : OptionConfigBaseParams -> CliBuilder(Try(I64, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.i64_list : OptionConfigBaseParams -> CliBuilder(List(I64), GetOptionsAction, GetOptionsAction)

Opt.i128 : DefaultableOptionConfigBaseParams(I128) -> CliBuilder(I128, GetOptionsAction, GetOptionsAction)

Opt.maybe_i128 : OptionConfigBaseParams -> CliBuilder(Try(I128, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.i128_list : OptionConfigBaseParams -> CliBuilder(List(I128), GetOptionsAction, GetOptionsAction)

Opt.number_single : DefaultableOptionConfigBaseParams(a), (Str -> Try(a, _)) -> CliBuilder(a, GetOptionsAction, GetOptionsAction)

Opt.number_maybe : OptionConfigBaseParams, (Str -> Try(a, _)) -> CliBuilder(Try(a, [NoValue]), GetOptionsAction, GetOptionsAction)

Opt.number_list : OptionConfigBaseParams, (Str -> Try(a, _)) -> CliBuilder(List(a), GetOptionsAction, GetOptionsAction)

Param.builder_with_parameter_parser : ParameterConfig, (List(Path) -> Try(data, ArgExtractErr)) -> CliBuilder(data, from_action, to_action)

Param.single : DefaultableParameterConfigParams(data) -> CliBuilder(data, { ..action }, GetParamsAction)

Param.maybe : ParameterConfigParams(data) -> CliBuilder(Try(data, [NoValue]), { ..action }, GetParamsAction)

Param.list : ParameterConfigParams(data) -> CliBuilder(List(data), { ..action }, StopCollectingAction)

Param.arg : DefaultableParameterConfigBaseParams(Path) -> CliBuilder(Path, { ..action }, GetParamsAction)

Param.maybe_arg : ParameterConfigBaseParams -> CliBuilder(ArgValue, { ..action }, GetParamsAction)

Param.arg_list : ParameterConfigBaseParams -> CliBuilder(List(Path), { ..action }, StopCollectingAction)

Param.bytes : DefaultableParameterConfigBaseParams(List(U8)) -> CliBuilder(List(U8), { ..action }, GetParamsAction)

Param.maybe_bytes : ParameterConfigBaseParams -> CliBuilder(Try(List(U8), [NoValue]), { ..action }, GetParamsAction)

Param.bytes_list : ParameterConfigBaseParams -> CliBuilder(List(List(U8)), { ..action }, StopCollectingAction)

Param.str : DefaultableParameterConfigBaseParams(Str) -> CliBuilder(Str, { ..action }, GetParamsAction)

Param.maybe_str : ParameterConfigBaseParams -> CliBuilder(Try(Str, [NoValue]), { ..action }, GetParamsAction)

Param.str_list : ParameterConfigBaseParams -> CliBuilder(List(Str), { ..action }, StopCollectingAction)

Param.dec : DefaultableParameterConfigBaseParams(Dec) -> CliBuilder(Dec, { ..action }, GetParamsAction)

Param.maybe_dec : ParameterConfigBaseParams -> CliBuilder(Try(Dec, [NoValue]), { ..action }, GetParamsAction)

Param.dec_list : ParameterConfigBaseParams -> CliBuilder(List(Dec), { ..action }, StopCollectingAction)

Param.f32 : DefaultableParameterConfigBaseParams(F32) -> CliBuilder(F32, { ..action }, GetParamsAction)

Param.maybe_f32 : ParameterConfigBaseParams -> CliBuilder(Try(F32, [NoValue]), { ..action }, GetParamsAction)

Param.f32_list : ParameterConfigBaseParams -> CliBuilder(List(F32), { ..action }, StopCollectingAction)

Param.f64 : DefaultableParameterConfigBaseParams(F64) -> CliBuilder(F64, { ..action }, GetParamsAction)

Param.maybe_f64 : ParameterConfigBaseParams -> CliBuilder(Try(F64, [NoValue]), { ..action }, GetParamsAction)

Param.f64_list : ParameterConfigBaseParams -> CliBuilder(List(F64), { ..action }, StopCollectingAction)

Param.u8 : DefaultableParameterConfigBaseParams(U8) -> CliBuilder(U8, { ..action }, GetParamsAction)

Param.maybe_u8 : ParameterConfigBaseParams -> CliBuilder(Try(U8, [NoValue]), { ..action }, GetParamsAction)

Param.u8_list : ParameterConfigBaseParams -> CliBuilder(List(U8), { ..action }, StopCollectingAction)

Param.u16 : DefaultableParameterConfigBaseParams(U16) -> CliBuilder(U16, { ..action }, GetParamsAction)

Param.maybe_u16 : ParameterConfigBaseParams -> CliBuilder(Try(U16, [NoValue]), { ..action }, GetParamsAction)

Param.u16_list : ParameterConfigBaseParams -> CliBuilder(List(U16), { ..action }, StopCollectingAction)

Param.u32 : DefaultableParameterConfigBaseParams(U32) -> CliBuilder(U32, { ..action }, GetParamsAction)

Param.maybe_u32 : ParameterConfigBaseParams -> CliBuilder(Try(U32, [NoValue]), { ..action }, GetParamsAction)

Param.u32_list : ParameterConfigBaseParams -> CliBuilder(List(U32), { ..action }, StopCollectingAction)

Param.u64 : DefaultableParameterConfigBaseParams(U64) -> CliBuilder(U64, { ..action }, GetParamsAction)

Param.maybe_u64 : ParameterConfigBaseParams -> CliBuilder(Try(U64, [NoValue]), { ..action }, GetParamsAction)

Param.u64_list : ParameterConfigBaseParams -> CliBuilder(List(U64), { ..action }, StopCollectingAction)

Param.u128 : DefaultableParameterConfigBaseParams(U128) -> CliBuilder(U128, { ..action }, GetParamsAction)

Param.maybe_u128 : ParameterConfigBaseParams -> CliBuilder(Try(U128, [NoValue]), { ..action }, GetParamsAction)

Param.u128_list : ParameterConfigBaseParams -> CliBuilder(List(U128), { ..action }, StopCollectingAction)

Param.i8 : DefaultableParameterConfigBaseParams(I8) -> CliBuilder(I8, { ..action }, GetParamsAction)

Param.maybe_i8 : ParameterConfigBaseParams -> CliBuilder(Try(I8, [NoValue]), { ..action }, GetParamsAction)

Param.i8_list : ParameterConfigBaseParams -> CliBuilder(List(I8), { ..action }, StopCollectingAction)

Param.i16 : DefaultableParameterConfigBaseParams(I16) -> CliBuilder(I16, { ..action }, GetParamsAction)

Param.maybe_i16 : ParameterConfigBaseParams -> CliBuilder(Try(I16, [NoValue]), { ..action }, GetParamsAction)

Param.i16_list : ParameterConfigBaseParams -> CliBuilder(List(I16), { ..action }, StopCollectingAction)

Param.i32 : DefaultableParameterConfigBaseParams(I32) -> CliBuilder(I32, { ..action }, GetParamsAction)

Param.maybe_i32 : ParameterConfigBaseParams -> CliBuilder(Try(I32, [NoValue]), { ..action }, GetParamsAction)

Param.i32_list : ParameterConfigBaseParams -> CliBuilder(List(I32), { ..action }, StopCollectingAction)

Param.i64 : DefaultableParameterConfigBaseParams(I64) -> CliBuilder(I64, { ..action }, GetParamsAction)

Param.maybe_i64 : ParameterConfigBaseParams -> CliBuilder(Try(I64, [NoValue]), { ..action }, GetParamsAction)

Param.i64_list : ParameterConfigBaseParams -> CliBuilder(List(I64), { ..action }, StopCollectingAction)

Param.i128 : DefaultableParameterConfigBaseParams(I128) -> CliBuilder(I128, { ..action }, GetParamsAction)

Param.maybe_i128 : ParameterConfigBaseParams -> CliBuilder(Try(I128, [NoValue]), { ..action }, GetParamsAction)

Param.i128_list : ParameterConfigBaseParams -> CliBuilder(List(I128), { ..action }, StopCollectingAction)

Param.number_single : DefaultableParameterConfigBaseParams(a), (Str -> Try(a, _)) -> CliBuilder(a, { ..action }, GetParamsAction)

Param.number_maybe : ParameterConfigBaseParams, (Str -> Try(a, _)) -> CliBuilder(Try(a, [NoValue]), { ..action }, GetParamsAction)

Param.number_list : ParameterConfigBaseParams, (Str -> Try(a, _)) -> CliBuilder(List(a), { ..action }, StopCollectingAction)

SubCmd.empty : { name : Str, description : Str, value : common_state } -> SubcommandParserConfig(common_state)

SubCmd.finish : CliBuilder(state, from_action, to_action), { name : Str, description : Str, mapper : state -> common_state } -> SubcommandParserConfig(common_state)

SubCmd.get_first_arg_to_check_for_subcommand_call : ArgParserState(_), List(SubcommandParserConfig(sub_state)), (Try(SubcommandParserConfig(sub_state), [AfterDelimiter, NoArgument, UnknownCommand(Path)]) -> ArgParserResult(ArgParserState(state))) -> ArgParserResult(ArgParserState(state))

SubCmd.optional : List(SubcommandParserConfig(sub_state)) -> CliBuilder(Try(sub_state, [NoSubcommand]), GetOptionsAction, GetParamsAction)

SubCmd.required : List(SubcommandParserConfig(sub_data)) -> CliBuilder(sub_data, GetOptionsAction, GetParamsAction)

SubCmd.SubcommandParserConfig : { name : Str, parser : ArgParser(sub_state), config : SubcommandConfig }

Validate.validate_cli : CliConfig -> Try({ }, CliValidationErr)

Validate.validate_command : { name : Str, options : List(OptionConfig), parent_options : List(OptionAtSubcommand), parameters : List(ParameterConfig), subcommands : SubcommandsConfig, subcommand_path : List(Str) } -> Try({ }, CliValidationErr)

Validate.ensure_command_is_well_named : NameAtSubcommand -> Try({ }, CliValidationErr)

Validate.ensure_param_is_well_named : NameAtSubcommand -> Try({ }, CliValidationErr)

Validate.ensure_option_is_well_named : OptionAtSubcommand -> Try({ }, CliValidationErr)

Validate.ensure_option_value_type_is_well_named : OptionAtSubcommand -> Try({ }, CliValidationErr)

Validate.ensure_param_value_type_is_well_named : ParamAtSubcommand -> Try({ }, CliValidationErr)

Validate.ensure_short_flag_is_well_named : NameAtSubcommand -> Try({ }, CliValidationErr)

Validate.ensure_long_flag_is_well_named : NameAtSubcommand -> Try({ }, CliValidationErr)

Validate.check_if_there_are_overlapping_options : List(OptionAtSubcommand) -> Try({ }, CliValidationErr)

Validate.check_if_there_are_overlapping_parameters : List(ParameterConfig), List(Str) -> Try({ }, CliValidationErr)

Validate.NameAtSubcommand : { name : Str, subcommand_path : List(Str) }

Validate.OptionAtSubcommand : { option : OptionConfig, subcommand_path : List(Str) }

Validate.ParamAtSubcommand : { param : ParameterConfig, subcommand_path : List(Str) }

Validate.CliValidationErr : [OverlappingParameterNames({ first : Str, second : Str, subcommand_path : List(Str) }), OverlappingOptionNames({ left : OptionAtSubcommand, right : OptionAtSubcommand }), DuplicateSubcommandName(NameAtSubcommand), RequiredSubcommandsCannotBeEmpty(List(Str)), InvalidShortFlagName(NameAtSubcommand), InvalidLongFlagName(NameAtSubcommand), InvalidCommandName(NameAtSubcommand), InvalidParameterName(NameAtSubcommand), OptionMustHaveShortOrLongName({ subcommand_path : List(Str) }), InvalidOptionValueType(OptionAtSubcommand), InvalidParameterValueType(ParamAtSubcommand), OverrodeSpecialHelpFlag(OptionAtSubcommand), OverrodeSpecialVersionFlag(OptionAtSubcommand)]