netrc-parser/lib/token.d.ts

export declare type MachineProps = 'login' | 'account' | 'password';
export interface Macdef {
    type: 'macdef';
    content: string;
}
export interface Newline {
    type: 'newline';
    content: string;
}
export interface Comment {
    type: 'comment';
    content: string;
}
export declare type Token = Machine | Prop | DefaultMachine | Macdef | Newline | Comment;
export interface IMachine {
    login?: string;
    password?: string;
    account?: string;
}
export interface Options {
    pre?: string;
    post?: string;
    elements?: Element[];
}
export declare abstract class Base {
    pre: string;
    post: string;
    protected _tokens?: Token[];
    constructor({pre, post}?: Options);
    addToken(token: Token): void;
    readonly content: string;
    protected readonly _content: string;
}
export declare class Prop extends Base {
    type: 'prop';
    name: MachineProps;
    value: string;
    constructor(opts: Options & {
        name: MachineProps;
        value: string;
    });
    protected readonly _content: string;
}
export interface MachineOptions extends Options {
    login?: string;
    password?: string;
    account?: string;
}
export declare abstract class MachineBase extends Base {
    protected _tokens: Token[];
    constructor({login, password, account, ...opts}?: MachineOptions);
    login: string | undefined;
    password: string | undefined;
    account: string | undefined;
    private getProp(name);
    private setProp(name, value);
    private readonly _props;
    private newPropPre();
    private newPropPost();
    private isMultiline();
}
export declare class Machine extends MachineBase {
    type: 'machine';
    host: string;
    constructor({host, ...opts}: MachineOptions & {
        host: string;
    });
    protected readonly _content: string;
}
export declare class DefaultMachine extends MachineBase {
    type: 'default';
    protected readonly _content: string;
}
export interface Machines {
    [host: string]: IMachine;
}
export declare function machinesProxy(tokens?: Token[]): Machines;