import type { Literal, Position } from 'unist';
import type { Token } from './tokenize.js';
export declare const Event: {
    readonly Name: "Name";
    readonly Directive: "Directive";
    readonly WhiteSpace: "WhiteSpace";
    readonly Comment: "Comment";
    readonly NewLine: "NewLine";
    readonly Error: "Error";
};
/**
 * [`unist`](https://github.com/syntax-tree/unist)-compatible node interface.
 */
export type Event = Event.Name | Event.Directive | Event.WhiteSpace | Event.Comment | Event.NewLine | Event.Error;
export declare namespace Event {
    interface Base<out T extends keyof typeof Event> extends Literal {
        type: T;
        position: Token['position'];
        value: string;
    }
    export interface Name extends Base<typeof Event.Name> {
    }
    export interface WhiteSpace extends Base<typeof Event.WhiteSpace> {
    }
    export interface NewLine extends Base<typeof Event.NewLine> {
    }
    export interface Comment extends Base<typeof Event.Comment> {
    }
    export interface Directive extends Base<typeof Event.Directive> {
        value: typeof Directive[keyof typeof Directive];
    }
    export interface Error extends Base<typeof Event.Error> {
        data: {
            message: Message;
        };
    }
    export {};
}
export declare const Directive: {
    readonly Hard: "hard";
    readonly Soft: "soft";
    readonly Package: "package";
};
export type Directive = typeof Directive[keyof typeof Directive];
/**
 * Diagnostic message format. Can be used with
 * [`vfile-message`](https://www.npmjs.com/package/vfile-message).
 */
export interface Message {
    ruleId: RuleId;
    reason: string;
    fatal: Severity;
    place: Position;
    actual?: string;
    expected?: string[];
}
export declare const Severity: {
    readonly Error: true;
    readonly Warning: false;
    readonly Info: undefined;
};
export type Severity = typeof Severity[keyof typeof Severity];
export type RuleId = typeof RULES[keyof typeof RULES]['ruleId'] | 'too-many-arguments';
export declare function validate(event: Readonly<Event>): Generator<Message, void, undefined>;
declare const RULES: {
    readonly Name: {
        readonly ruleId: "illegal-character-in-package-name";
        readonly reason: "this character is not allowed in package names";
        readonly fatal: false;
        readonly expected: string[];
        readonly re: RegExp;
    };
    readonly WhiteSpace: {
        readonly ruleId: "illegal-whitespace-character";
        readonly reason: "this character cannot be used as a whitespace character";
        readonly fatal: false;
        readonly expected: string[];
        readonly re: RegExp;
    };
    readonly NewLine: {
        readonly ruleId: "illegal-newline-character";
        readonly reason: "this character cannot be used as a newline sequence";
        readonly fatal: false;
        readonly expected: string[];
        readonly re: RegExp;
    };
};
export {};