import { GherkinDocument, Location, Comment, Feature, Tag, FeatureChild, Rule, Background, Scenario, Examples, Step, TableRow, TableCell, StepKeywordType, DocString, DataTable, RuleChild } from '@cucumber/messages';
export type GherkinNodeWithLocation = Comment | Feature | Tag | Scenario | Rule | Background | Examples | Step | TableRow | TableCell | DocString | DataTable;
export type GherkinNode = GherkinNodeWithLocation | GherkinDocument | FeatureChild | RuleChild;
export declare function isWithLocation(node: unknown): node is GherkinNodeWithLocation;
export declare abstract class TypedGherkinNode<N extends GherkinNode> {
    constructor(originalNode: N);
}
export interface HasChildren<N extends TypedGherkinNode<N>> {
    get children(): ReadonlyArray<TypedGherkinNode<N>>;
}
export declare function isHasChildren<N extends TypedGherkinNode<N>>(node: unknown): node is HasChildren<N>;
export interface HasChild<N extends TypedGherkinNode<N>> {
    get child(): undefined | TypedGherkinNode<N>;
}
export declare function isHasChild<N extends TypedGherkinNode<N>>(node: unknown): node is HasChild<N>;
export declare abstract class TypedGherkinNodeWithLocation<N extends GherkinNodeWithLocation> extends TypedGherkinNode<N> {
    location: Location;
    constructor(originalNode: N);
    get lastLine(): number;
}
type Options = {
    escapeBackslashes: boolean;
};
export declare class TypedGherkinDocument extends TypedGherkinNode<GherkinDocument> implements GherkinDocument, HasChild<TypedFeature> {
    uri?: string;
    feature?: TypedFeature;
    comments: readonly TypedComment[];
    constructor(originalNode: GherkinDocument, options: Options);
    get child(): undefined | TypedFeature;
}
export declare class TypedFeature extends TypedGherkinNodeWithLocation<Feature> implements Feature, HasChildren<TypedFeatureChild> {
    tags: readonly TypedTag[];
    language: string;
    keyword: string;
    name: string;
    description: string;
    children: readonly TypedFeatureChild[];
    constructor(originalNode: Feature);
}
export declare class TypedTag extends TypedGherkinNodeWithLocation<Tag> implements Tag {
    name: string;
    id: string;
    constructor(originalNode: Tag);
}
export declare class TypedComment extends TypedGherkinNodeWithLocation<Comment> implements Comment {
    text: string;
    constructor(originalNode: Comment);
    get value(): string;
}
export declare class TypedFeatureChild extends TypedGherkinNode<FeatureChild> implements FeatureChild, HasChild<TypedRule | TypedScenario | TypedBackground> {
    rule?: TypedRule;
    background?: TypedBackground;
    scenario?: TypedScenario;
    constructor(originalNode: FeatureChild);
    get child(): undefined | TypedRule | TypedScenario | TypedBackground;
}
export declare class TypedRule extends TypedGherkinNodeWithLocation<Rule> implements Rule, HasChildren<TypedRuleChild> {
    tags: readonly TypedTag[];
    keyword: string;
    name: string;
    description: string;
    children: readonly TypedRuleChild[];
    id: string;
    constructor(originalNode: Rule);
}
export declare class TypedRuleChild extends TypedGherkinNode<RuleChild> implements RuleChild, HasChild<TypedScenario> {
    background?: TypedBackground;
    scenario?: TypedScenario;
    constructor(originalNode: RuleChild);
    get child(): undefined | TypedScenario;
}
export declare class TypedBackground extends TypedGherkinNodeWithLocation<Background> implements Background, HasChildren<TypedStep> {
    keyword: string;
    name: string;
    description: string;
    steps: readonly TypedStep[];
    id: string;
    constructor(originalNode: Background);
    get children(): ReadonlyArray<TypedStep>;
}
export declare class TypedStep extends TypedGherkinNodeWithLocation<Step> implements Step, HasChildren<TypedDataTable | TypedDocString> {
    keyword: string;
    keywordType?: StepKeywordType;
    text: string;
    docString?: TypedDocString;
    dataTable?: TypedDataTable;
    id: string;
    constructor(originalNode: Step);
    get children(): ReadonlyArray<TypedDataTable | TypedDocString>;
    get lastLine(): number;
}
export declare class TypedScenario extends TypedGherkinNodeWithLocation<Scenario> implements Scenario, HasChildren<TypedStep | TypedExamples | TypedTag> {
    tags: readonly TypedTag[];
    keyword: string;
    name: string;
    description: string;
    steps: readonly TypedStep[];
    examples: readonly TypedExamples[];
    id: string;
    constructor(originalNode: Scenario);
    get children(): ReadonlyArray<TypedStep | TypedExamples | TypedTag>;
}
export declare class TypedExamples extends TypedGherkinNodeWithLocation<Examples> implements Examples, HasChildren<TypedTableRow | TypedTag> {
    tags: readonly TypedTag[];
    keyword: string;
    name: string;
    description: string;
    tableHeader?: TypedTableRow;
    tableBody: readonly TypedTableRow[];
    id: string;
    constructor(originalNode: Examples);
    get children(): ReadonlyArray<TypedTableRow | TypedTag>;
}
export declare class TypedTableRow extends TypedGherkinNodeWithLocation<TableRow> implements TableRow, HasChildren<TypedTableCell> {
    cells: readonly TypedTableCell[];
    id: string;
    columnSizes: number[] | undefined;
    constructor(originalNode: TableRow, columnSizes: number[]);
    get children(): ReadonlyArray<TypedTableCell>;
}
export declare class TypedTableCell extends TypedGherkinNodeWithLocation<TableCell> implements TableCell {
    value: string;
    displaySize: number;
    constructor(originalNode: TableCell, displaySize: number);
}
export declare class TypedDocString extends TypedGherkinNodeWithLocation<DocString> implements DocString {
    mediaType?: string;
    content: string;
    delimiter: string;
    constructor(originalNode: DocString);
    get nbRows(): number;
}
export declare class TypedDataTable extends TypedGherkinNodeWithLocation<DataTable> implements DataTable, HasChildren<TypedTableRow> {
    rows: readonly TypedTableRow[];
    constructor(originalNode: DataTable);
    get nbRows(): number;
    get children(): ReadonlyArray<TypedTableRow>;
}
export {};
//# sourceMappingURL=index.d.ts.map