amazon-route-53-dns-zone-file/dist/parser/types_parser.d.ts

Makes DNS Zone File easy. Parses and validates BIND zone files and can be extended for custom features. Functionality is modular. Features are made open for extension and closed for runtime mutation. Written in TypeScript.

/**
 * start of every record is:
 * @format $start = `[name?] [ttl?] IN _TYPE_ `
 */
import { ParsedTypings } from '../shared/types_domain_specific';
import { InstructionType, ErrorKeyKind, DirectiveKind } from '../shared/constants_domain_specific';
/**
 * @note ParsingRecordDataType + ClientRecordType & ApiRecordType
 * @description parts of a resource record being-parsed or already parsed
 */
export interface ParsingRecordDataType {
    tokens: string[];
    values: string[];
    name: string;
    /** nested parsing */
    previousName: string;
    ttl?: number;
}
export interface Common {
    /** directive or record type */
    instructionType: unknown;
    /** usually a string */
    value: unknown;
    /** raw input */
    lineContent: string;
    /** actual error */
    error?: unknown;
    /** ErrorKeyKind */
    errorType?: string;
}
declare namespace Internals {
    type SOA = Common & {
        instructionType: 'SOA';
        value: ParsedTypings.Obj['SOA'];
    };
    type Records = {
        SOA: SOA;
    } & {
        [Key in InputTypings.SupportedRecordType]: Common & {
            instructionType: Key;
            value: ParsedTypings.ByType[Key];
        };
    };
    interface TimeToLive extends Common {
        instructionType: DirectiveKind.TimeToLive;
        value: number;
        errorType: ErrorKeyKind.TtlInvalidFormat | ErrorKeyKind.TtlOverflow | ErrorKeyKind.TtlMissingDefault;
    }
    interface Origin extends Common {
        instructionType: DirectiveKind.Origin;
        value: string;
    }
    type Directives = {
        [DirectiveKind.TimeToLive]: TimeToLive;
        [DirectiveKind.Origin]: Origin;
    };
    type Problems = {
        [Key in ErrorKeyKind]: Common & {
            instructionType: Key;
            value: string;
        };
    };
    export type Indexed = Directives & Problems & Records;
    export {};
}
/** import zone file text input */
export declare namespace InputTypings {
    /** supported by the parser */
    type SupportedRecordType = 'TXT' | 'NS' | 'A' | 'AAAA' | 'CNAME' | 'MX' | 'PTR' | 'SPF' | 'SRV' | 'CAA' | 'NAPTR';
    /** @desc a directive or a record - the beginning of a line */
    type Instruction = InstructionType;
    /** @note currently unused, here for future possible usage */
    type FileFormatVariations = ['name', 'ttl', 'class', 'type', 'data'] | ['ttl', 'class', 'type', 'data'] | ['class', 'type', 'data'];
}
export declare namespace SourceMapTypings {
    type Value = Internals.Indexed[keyof Internals.Indexed];
    /** @example type Store = Map<number, Value> */
    interface Store extends Map<number, any> {
        has(key: number): boolean;
        get<Instruction extends Value['instructionType']>(key: number): Internals.Indexed[Instruction] | undefined;
        set<Instruction extends Value['instructionType']>(key: number, value: Internals.Indexed[Instruction]): this;
    }
}
export declare namespace ParserTypings {
    interface Parser {
        zoneObj: ParsedTypings.Obj;
        parsingMeta: SourceMapTypings.Store;
        stack: {
            name?: string;
        }[];
        visitors: Visitor[];
        input: {
            $originName?: string;
            textInput: string;
            textInputFlattened: string;
            textInputSplitByLine: string[];
        };
    }
    type MetaArg = Omit<SourceMapTypings.Value, 'lineContent' | 'value'> & {
        value?: SourceMapTypings.Value['value'];
    };
    interface Node {
        addMeta: (meta: MetaArg) => void;
        index: number;
        lineContent: string;
        lineParts: string[];
    }
    type Visitor = {
        isSatisfied(node: Node): boolean;
        visit(parser: Parser, node: Node): void;
    };
}
export {};
//# sourceMappingURL=types_parser.d.ts.map