decline-ts/lib/Opts.d.ts

Composable command-line parser for TypeScript - a (partial) porting of Scala decline using fp-ts

import { alt as Alt, eq as Eq, apply, either, option as maybe, readonlyNonEmptyArray } from 'fp-ts';
import { Lazy, Predicate } from 'fp-ts/function';
import { Option } from 'fp-ts/Option';
import { ReadonlyNonEmptyArray } from 'fp-ts/ReadonlyNonEmptyArray';
import { Command } from './Command';
import { ValidatedNea } from './ValidatedNea';
declare type Validation<A> = (raw: string) => ValidatedNea<string, A>;
declare const URI_ = "Opts";
declare type URI_ = typeof URI_;
declare module 'fp-ts/HKT' {
    interface URItoKind<A> {
        readonly [URI_]: Opts<A>;
    }
}
declare type OptionArgs = {
    readonly long: string;
    readonly help: string;
    readonly short?: string;
    readonly metavar: string;
};
declare type FlagArgs = {
    readonly long: string;
    readonly help: string;
    readonly short?: string;
};
export declare type Opts<A> = Opts.Pure<A> | Opts.App<unknown, A> | Opts.OrElse<A> | Opts.Single<A> | Opts.Repeated<A> | Opts.Subcommand<A> | Opts.Validate<unknown, A> | Opts.HelpFlag;
export declare namespace Opts {
    type Pure<A> = {
        readonly _tag: 'Pure';
        readonly a: A;
    };
    type App<A, B> = {
        readonly _tag: 'App';
        readonly f: Opts<(a: A) => B>;
        readonly a: Opts<A>;
    };
    type OrElse<A> = {
        readonly _tag: 'OrElse';
        readonly a: Opts<A>;
        readonly b: Opts<A>;
    };
    type Single<A> = {
        readonly _tag: 'Single';
        readonly opt: Opt<A>;
    };
    type Repeated<A> = {
        readonly _tag: 'Repeated';
        readonly opt: Opt<A>;
    };
    type Subcommand<A> = {
        readonly _tag: 'Subcommand';
        readonly command: Command<A>;
    };
    type Validate<A, B> = {
        readonly _tag: 'Validate';
        readonly value: Opts<A>;
        readonly validate: (a: A) => ValidatedNea<string, B>;
    };
    type HelpFlag = {
        readonly _tag: 'HelpFlag';
        readonly flag: Opts<void>;
    };
    /**
     * Constructors
     */
    const pure: <A>(a: A) => Pure<A>;
    const app: <A, B>(f: Opts<(a: A) => B>, fa: Opts<A>) => Opts<B>;
    const orElse: <A>(a: Opts<A>, b: Opts<A>) => Opts<A>;
    function single<A>(opt: Opt<A>): Single<A>;
    function repeated<A>(opt: Opt<A>): Opts<ReadonlyNonEmptyArray<A>>;
    function subcommand<A>(command: Command<A>): Subcommand<A>;
    function subcommand({ name, header }: Command.Args): <B>(o: Opts<B>) => Subcommand<B>;
    const helpFlag: (flag: Opts<void>) => Opts<never>;
    const unit: Opts<void>;
    function option(): (args: OptionArgs) => Opts<string>;
    function option<A>(codec: Validation<A>): (args: OptionArgs) => Opts<A>;
    function options(): (args: OptionArgs) => Opts<ReadonlyNonEmptyArray<string>>;
    function options<A>(codec: Validation<A>): (args: OptionArgs) => Opts<ReadonlyNonEmptyArray<A>>;
    const flag: ({ long, help, short }: FlagArgs) => Opts<void>;
    const flags: ({ long, help, short }: FlagArgs) => Opts<number>;
    function argument(): (metavar?: string) => Opts<string>;
    function argument<A>(codec: Validation<A>): (metavar?: string) => Opts<A>;
    function argumentS(): (metavar: string) => Opts<ReadonlyNonEmptyArray<string>>;
    function argumentS<A>(codec: Validation<A>): (metavar: string) => Opts<ReadonlyNonEmptyArray<A>>;
    function param(): (metavar: string) => Opts<string>;
    function param<A>(codec: Validation<A>): (metavar: string) => Opts<A>;
    function params(): (metavar: string) => Opts<ReadonlyNonEmptyArray<string>>;
    function params<A>(codec: Validation<A>): (metavar: string) => Opts<ReadonlyNonEmptyArray<A>>;
    /**
     * Methods
     */
    const mapValidated: <A, B>(f: (a: A) => either.Either<readonlyNonEmptyArray.ReadonlyNonEmptyArray<string>, B>) => (fa: Opts<A>) => Opts<B>;
    const validate: (message: string) => <A>(pred: Predicate<A>) => (fa: Opts<A>) => Opts<A>;
    const withDefault: <A>(fy: Lazy<A>) => (fa: Opts<A>) => Opts<A>;
    const orNone: <A>(fa: Opts<A>) => Opts<maybe.Option<A>>;
    const orEmpty: <A>(fa: Opts<readonlyNonEmptyArray.ReadonlyNonEmptyArray<A>>) => Opts<readonly A[]>;
    const orFalse: (fa: Opts<unknown>) => Opts<boolean>;
    const asHelp: (fa: Opts<unknown>) => Opts<never>;
    const map: <A, B>(f: (a: A) => B) => (fa: Opts<A>) => Opts<B>;
    const ap: <A, B>(fab: Opts<(a: A) => B>) => (fa: Opts<A>) => Opts<B>;
    const alt: <A>(that: Lazy<Opts<A>>) => (fa: Opts<A>) => Opts<A>;
    /**
     * Instance
     */
    const URI = "Opts";
    type URI = URI_;
    const opts: apply.Apply1<URI> & Alt.Alt1<URI>;
    /**
     * Name
     */
    type Name = Name.LongName | Name.ShortName;
    namespace Name {
        type LongName = {
            readonly _tag: 'LongName';
            readonly flag: string;
        };
        type ShortName = {
            readonly _tag: 'ShortName';
            readonly flag: string;
        };
        const longName: (flag: string) => LongName;
        const shortName: (flag: string) => ShortName;
        const stringify: (name: Name) => string;
        const namesFor: (long: string, short: string) => ReadonlyArray<Name>;
        const eq: Eq.Eq<Name>;
    }
    /**
     * Opt
     */
    type Opt<A> = Opt.Regular | Opt.Flag | Opt.Argument;
    namespace Opt {
        type Regular = {
            readonly _tag: 'Regular';
            readonly names: ReadonlyArray<Name>;
            readonly metavar: string;
            readonly help: string;
        };
        type Flag = {
            readonly _tag: 'Flag';
            readonly names: ReadonlyArray<Name>;
            readonly help: string;
        };
        type Argument = {
            readonly _tag: 'Argument';
            readonly metavar: string;
        };
        const regular: (names: ReadonlyArray<Name>, metavar: string, help: string) => Opt<string>;
        const flag: (names: ReadonlyArray<Name>, help: string) => Opt<void>;
        const argument: (metavar: string) => Opt<string>;
        function eq<A>(): Eq.Eq<Opt<A>>;
    }
}
export {};