eslint-markdown 0.11.0 → 0.12.0

package/build/index.d.ts

@@ -1,17 +1,1394 @@
+/**
+ * @fileoverview Entry file for the `eslint-markdown` package.
+ */
+import { all, base, recommended, stylistic } from './configs/index.js';
+declare const plugin: {
+    readonly meta: {
+        readonly name: "eslint-markdown";
+        readonly version: string;
+    };
+    readonly rules: {
+        'allow-heading': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Enforce the use of allowed or disallowed headings";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: false;
+                };
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly h1: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly allow: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                                readonly disallow: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                        readonly h2: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly allow: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                                readonly disallow: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                        readonly h3: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly allow: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                                readonly disallow: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                        readonly h4: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly allow: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                                readonly disallow: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                        readonly h5: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly allow: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                                readonly disallow: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                        readonly h6: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly allow: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                                readonly disallow: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "object";
+                                    };
+                                    readonly uniqueItems: true;
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly h1: {
+                        readonly allow: [RegExp];
+                        readonly disallow: [];
+                    };
+                    readonly h2: {
+                        readonly allow: [RegExp];
+                        readonly disallow: [];
+                    };
+                    readonly h3: {
+                        readonly allow: [RegExp];
+                        readonly disallow: [];
+                    };
+                    readonly h4: {
+                        readonly allow: [RegExp];
+                        readonly disallow: [];
+                    };
+                    readonly h5: {
+                        readonly allow: [RegExp];
+                        readonly disallow: [];
+                    };
+                    readonly h6: {
+                        readonly allow: [RegExp];
+                        readonly disallow: [];
+                    };
+                }];
+                readonly messages: {
+                    readonly allowHeading: "The level {{ depth }} heading `{{ heading }}` is not in the list of allowed headings. (Allow: {{ allow }}).";
+                    readonly disallowHeading: "The level {{ depth }} heading `{{ heading }}` is in the list of disallowed headings. (Disallow: {{ disallow }}).";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [Record<"h1" | "h2" | "h3" | "h4" | "h5" | "h6", import("./rules/allow-heading.js").HeadingOptions>];
+                Node: import("mdast").Node;
+                MessageIds: "allowHeading" | "disallowHeading";
+            }>) => {
+                heading(node: import("mdast").Heading): void;
+            };
+        };
+        'allow-image-url': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Enforce the use of allowed or disallowed URLs for images";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: false;
+                };
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly allowUrls: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                        readonly disallowUrls: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                        readonly allowDefinitions: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly allowUrls: [RegExp];
+                    readonly disallowUrls: [];
+                    readonly allowDefinitions: ["//"];
+                }];
+                readonly messages: {
+                    readonly allowImageUrl: "The URL `{{ url }}` is not in the list of allowed URLs. (Allow: {{ patterns }}).";
+                    readonly disallowImageUrl: "The URL `{{ url }}` is in the list of disallowed URLs. (Disallow: {{ patterns }}).";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    allowUrls: RegExp[];
+                    disallowUrls: RegExp[];
+                    allowDefinitions: string[];
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "allowImageUrl" | "disallowImageUrl";
+            }>) => {
+                image(node: import("mdast").Image): void;
+                html(node: import("mdast").Html): void;
+                imageReference(node: import("mdast").ImageReference): void;
+                definition(node: import("mdast").Definition): void;
+                'root:exit'(): void;
+            };
+        };
+        'allow-link-url': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Enforce the use of allowed or disallowed URLs for links";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: false;
+                };
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly allowUrls: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                        readonly disallowUrls: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "object";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                        readonly allowDefinitions: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly allowUrls: [RegExp];
+                    readonly disallowUrls: [];
+                    readonly allowDefinitions: ["//"];
+                }];
+                readonly messages: {
+                    readonly allowLinkUrl: "The URL `{{ url }}` is not in the list of allowed URLs. (Allow: {{ patterns }}).";
+                    readonly disallowLinkUrl: "The URL `{{ url }}` is in the list of disallowed URLs. (Disallow: {{ patterns }}).";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    allowUrls: RegExp[];
+                    disallowUrls: RegExp[];
+                    allowDefinitions: string[];
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "allowLinkUrl" | "disallowLinkUrl";
+            }>) => {
+                link(node: import("mdast").Link): void;
+                html(node: import("mdast").Html): void;
+                linkReference(node: import("mdast").LinkReference): void;
+                definition(node: import("mdast").Definition): void;
+                'root:exit'(): void;
+            };
+        };
+        'code-lang-shorthand': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Enforce the use of shorthand for code block language identifiers";
+                    readonly url: string;
+                    readonly recommended: true;
+                    readonly stylistic: false;
+                };
+                readonly fixable: "code";
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly allow: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                        readonly override: {
+                            readonly type: "object";
+                            readonly additionalProperties: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly allow: [];
+                    readonly override: {};
+                }];
+                readonly messages: {
+                    readonly codeLangShorthand: "`{{ lang }}` should be shortened to `{{ langShorthand }}`.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    allow: string[];
+                    override: Record<string, string>;
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "codeLangShorthand";
+            }>) => {
+                code(node: import("mdast").Code): void;
+            };
+        };
+        'consistent-code-style': {
+            readonly meta: {
+                readonly type: "layout";
+                readonly docs: {
+                    readonly description: "Enforce consistent code style";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: true;
+                };
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly style: {
+                            readonly enum: ["consistent", "indent", "fence-backtick", "fence-tilde"];
+                        };
+                        readonly blankLineAbove: {
+                            readonly oneOf: [{
+                                readonly enum: [false];
+                            }, {
+                                readonly type: "integer";
+                                readonly minimum: 1;
+                            }];
+                        };
+                        readonly blankLineBelow: {
+                            readonly oneOf: [{
+                                readonly enum: [false];
+                            }, {
+                                readonly type: "integer";
+                                readonly minimum: 1;
+                            }];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly style: "consistent";
+                    readonly blankLineAbove: false;
+                    readonly blankLineBelow: false;
+                }];
+                readonly messages: {
+                    readonly style: "Code style should be `{{ style }}`.";
+                    readonly blankLineAbove: "Code should be surrounded by {{ blankLineAbove }} blank line(s) above.";
+                    readonly blankLineBelow: "Code should be surrounded by {{ blankLineBelow }} blank line(s) below.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    style: "consistent" | ("indent" | "fence-backtick" | "fence-tilde");
+                    blankLineAbove: number | false;
+                    blankLineBelow: number | false;
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "style" | "blankLineAbove" | "blankLineBelow";
+            }>) => {
+                blockquote(): void;
+                code(node: import("mdast").Code): void;
+                'blockquote:exit'(): void;
+            };
+        };
+        'consistent-delete-style': {
+            readonly meta: {
+                readonly type: "layout";
+                readonly docs: {
+                    readonly description: "Enforce consistent delete style";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: true;
+                };
+                readonly fixable: "code";
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly style: {
+                            readonly enum: ["consistent", "~", "~~"];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly style: "consistent";
+                }];
+                readonly messages: {
+                    readonly style: "Delete style should be `{{ style }}`.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    style: "consistent" | "~" | "~~";
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "style";
+            }>) => {
+                delete(node: import("mdast").Delete): void;
+            };
+        };
+        'consistent-emphasis-style': {
+            readonly meta: {
+                readonly type: "layout";
+                readonly docs: {
+                    readonly description: "Enforce consistent emphasis style";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: true;
+                };
+                readonly fixable: "code";
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly style: {
+                            readonly enum: ["consistent", "*", "_"];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly style: "consistent";
+                }];
+                readonly messages: {
+                    readonly style: "Emphasis style should be `{{ style }}`.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    style: "consistent" | "*" | "_";
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "style";
+            }>) => {
+                emphasis(node: import("mdast").Emphasis): void;
+            };
+        };
+        'consistent-inline-code-style': {
+            readonly meta: {
+                readonly type: "layout";
+                readonly docs: {
+                    readonly description: "Enforce consistent inline code style";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: true;
+                };
+                readonly fixable: "whitespace";
+                readonly messages: {
+                    readonly style: "Inline code should not have extra spaces or tabs next to backticks.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [];
+                Node: import("mdast").Node;
+                MessageIds: "style";
+            }>) => {
+                inlineCode(node: import("mdast").InlineCode): void;
+            };
+        };
+        'consistent-strong-style': {
+            readonly meta: {
+                readonly type: "layout";
+                readonly docs: {
+                    readonly description: "Enforce consistent strong style";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: true;
+                };
+                readonly fixable: "code";
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly style: {
+                            readonly enum: ["consistent", "*", "_"];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly style: "consistent";
+                }];
+                readonly messages: {
+                    readonly style: "Strong style should be `{{ style }}`.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    style: "consistent" | "*" | "_";
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "style";
+            }>) => {
+                strong(node: import("mdast").Strong): void;
+            };
+        };
+        'consistent-thematic-break-style': {
+            readonly meta: {
+                readonly type: "layout";
+                readonly docs: {
+                    readonly description: "Enforce consistent thematic break style";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: true;
+                };
+                readonly fixable: "code";
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly style: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly style: "consistent";
+                }];
+                readonly messages: {
+                    readonly style: "Thematic break style should be `{{ style }}`.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    style: string;
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "style";
+            }>) => {
+                thematicBreak(node: import("mdast").ThematicBreak): void;
+            };
+        };
+        'consistent-unordered-list-style': {
+            readonly meta: {
+                readonly type: "layout";
+                readonly docs: {
+                    readonly description: "Enforce consistent unordered list style";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: true;
+                };
+                readonly fixable: "code";
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly style: {
+                            readonly enum: ["consistent", "sublist", "*", "+", "-"];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly style: "consistent";
+                }];
+                readonly messages: {
+                    readonly style: "Unordered list style should be `{{ style }}`.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    style: "consistent" | "sublist" | ("*" | "+" | "-");
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "style";
+            }>) => {
+                list(): void;
+                'list[ordered=false] > listItem'(node: import("mdast").ListItem): void;
+                'list:exit'(): void;
+            };
+        };
+        'no-consecutive-blank-line': {
+            readonly meta: {
+                readonly type: "layout";
+                readonly docs: {
+                    readonly description: "Disallow consecutive blank lines";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: true;
+                };
+                readonly fixable: "whitespace";
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly max: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                        };
+                        readonly skipCode: {
+                            readonly oneOf: [{
+                                readonly type: "boolean";
+                            }, {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                                readonly uniqueItems: true;
+                            }];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly max: 1;
+                    readonly skipCode: true;
+                }];
+                readonly messages: {
+                    readonly noConsecutiveBlankLine: "More than {{ max }} consecutive blank line(s) are not allowed.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    max: number;
+                    skipCode: boolean | string[];
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "noConsecutiveBlankLine";
+            }>) => {
+                code(node: import("mdast").Code): void;
+                'root:exit'(): void;
+            };
+        };
+        'no-control-character': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Disallow control character";
+                    readonly url: string;
+                    readonly recommended: true;
+                    readonly stylistic: false;
+                };
+                readonly hasSuggestions: true;
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly allow: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                        readonly skipCode: {
+                            readonly oneOf: [{
+                                readonly type: "boolean";
+                            }, {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                                readonly uniqueItems: true;
+                            }];
+                        };
+                        readonly skipInlineCode: {
+                            readonly type: "boolean";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly allow: [];
+                    readonly skipCode: true;
+                    readonly skipInlineCode: true;
+                }];
+                readonly messages: {
+                    readonly noControlCharacter: "Control character `{{ controlCharacter }}` is not allowed.";
+                    readonly suggestRemove: "Remove control character `{{ controlCharacter }}`.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    allow: string[];
+                    skipCode: boolean | string[];
+                    skipInlineCode: boolean;
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "noControlCharacter" | "suggestRemove";
+            }>) => {
+                code(node: import("mdast").Code): void;
+                inlineCode(node: import("mdast").InlineCode): void;
+                'root:exit'(): void;
+            };
+        };
+        'no-curly-quote': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Disallow curly quotes(`“`, `”`, `‘` or `’`) in text";
+                    readonly url: string;
+                    readonly recommended: true;
+                    readonly stylistic: false;
+                };
+                readonly fixable: "code";
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly checkLeftDoubleQuotationMark: {
+                            readonly type: "boolean";
+                        };
+                        readonly checkRightDoubleQuotationMark: {
+                            readonly type: "boolean";
+                        };
+                        readonly checkLeftSingleQuotationMark: {
+                            readonly type: "boolean";
+                        };
+                        readonly checkRightSingleQuotationMark: {
+                            readonly type: "boolean";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly checkLeftDoubleQuotationMark: true;
+                    readonly checkRightDoubleQuotationMark: true;
+                    readonly checkLeftSingleQuotationMark: true;
+                    readonly checkRightSingleQuotationMark: true;
+                }];
+                readonly messages: {
+                    readonly noCurlyQuote: "Curly quotes(`“`, `”`, `‘` or `’`) are not allowed. Use straight quotes(`\"` or `'`) instead.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    checkLeftDoubleQuotationMark: boolean;
+                    checkRightDoubleQuotationMark: boolean;
+                    checkLeftSingleQuotationMark: boolean;
+                    checkRightSingleQuotationMark: boolean;
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "noCurlyQuote";
+            }>) => {
+                text(node: import("mdast").Text): void;
+            };
+        };
+        'no-double-punctuation': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Disallow double consecutive punctuation in text";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: false;
+                };
+                readonly fixable: "code";
+                readonly hasSuggestions: true;
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly allow: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                                readonly minLength: 2;
+                                readonly maxLength: 2;
+                                readonly pattern: "^[!,.:;?]{2}$";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly allow: [];
+                }];
+                readonly messages: {
+                    readonly noDoublePunctuation: "Double punctuation mark `{{ punctuation }}` is not allowed.";
+                    readonly suggestReplaceWithLeft: "Replace `{{ punctuation }}` with the left punctuation mark `{{ leftPunctuation }}`.";
+                    readonly suggestReplaceWithRight: "Replace `{{ punctuation }}` with the right punctuation mark `{{ rightPunctuation }}`.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    allow: string[];
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "noDoublePunctuation" | "suggestReplaceWithLeft" | "suggestReplaceWithRight";
+            }>) => {
+                text(node: import("mdast").Text): void;
+            };
+        };
+        'no-double-space': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Disallow double or multiple consecutive spaces in text, except for leading and trailing spaces";
+                    readonly url: string;
+                    readonly recommended: true;
+                    readonly stylistic: false;
+                };
+                readonly fixable: "whitespace";
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly checkMultipleSpace: {
+                            readonly type: "boolean";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly checkMultipleSpace: false;
+                }];
+                readonly messages: {
+                    readonly noDoubleSpace: "Double spaces are not allowed except for leading and trailing spaces.";
+                    readonly noMultipleSpace: "Multiple spaces are not allowed except for leading and trailing spaces.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    checkMultipleSpace: boolean;
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "noDoubleSpace" | "noMultipleSpace";
+            }>) => {
+                text(node: import("mdast").Text): void;
+            };
+        };
+        'no-emoji': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Disallow emojis in text";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: false;
+                };
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly allow: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly allow: [];
+                }];
+                readonly messages: {
+                    readonly noEmoji: "Emojis are not allowed.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    allow: string[];
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "noEmoji";
+            }>) => {
+                text(node: import("mdast").Text): void;
+            };
+        };
+        'no-git-conflict-marker': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Disallow git conflict markers";
+                    readonly url: string;
+                    readonly recommended: true;
+                    readonly stylistic: false;
+                };
+                readonly fixable: "code";
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly skipCode: {
+                            readonly oneOf: [{
+                                readonly type: "boolean";
+                            }, {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                                readonly uniqueItems: true;
+                            }];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly skipCode: true;
+                }];
+                readonly messages: {
+                    readonly noGitConflictMarker: "Git conflict marker `{{ gitConflictMarker }}` is not allowed.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    skipCode: boolean | string[];
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "noGitConflictMarker";
+            }>) => {
+                code(node: import("mdast").Code): void;
+                'root:exit'(): void;
+            };
+        };
+        'no-irregular-dash': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Disallow irregular dash";
+                    readonly url: string;
+                    readonly recommended: true;
+                    readonly stylistic: false;
+                };
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly allow: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                        readonly skipCode: {
+                            readonly oneOf: [{
+                                readonly type: "boolean";
+                            }, {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                                readonly uniqueItems: true;
+                            }];
+                        };
+                        readonly skipInlineCode: {
+                            readonly type: "boolean";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly allow: [];
+                    readonly skipCode: true;
+                    readonly skipInlineCode: true;
+                }];
+                readonly messages: {
+                    readonly noIrregularDash: "Irregular dash `{{ irregularDash }}` is not allowed.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    allow: string[];
+                    skipCode: boolean | string[];
+                    skipInlineCode: boolean;
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "noIrregularDash";
+            }>) => {
+                code(node: import("mdast").Code): void;
+                inlineCode(node: import("mdast").InlineCode): void;
+                'root:exit'(): void;
+            };
+        };
+        'no-irregular-whitespace': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Disallow irregular whitespace";
+                    readonly url: string;
+                    readonly recommended: true;
+                    readonly stylistic: false;
+                };
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly allow: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                        readonly skipCode: {
+                            readonly oneOf: [{
+                                readonly type: "boolean";
+                            }, {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                                readonly uniqueItems: true;
+                            }];
+                        };
+                        readonly skipInlineCode: {
+                            readonly type: "boolean";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly allow: [];
+                    readonly skipCode: true;
+                    readonly skipInlineCode: true;
+                }];
+                readonly messages: {
+                    readonly noIrregularWhitespace: "Irregular whitespace `{{ irregularWhitespace }}` is not allowed.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    allow: string[];
+                    skipCode: boolean | string[];
+                    skipInlineCode: boolean;
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "noIrregularWhitespace";
+            }>) => {
+                code(node: import("mdast").Code): void;
+                inlineCode(node: import("mdast").InlineCode): void;
+                'root:exit'(): void;
+            };
+        };
+        'no-tab': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Disallow tab characters";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: true;
+                };
+                readonly fixable: "whitespace";
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly skipCode: {
+                            readonly oneOf: [{
+                                readonly type: "boolean";
+                            }, {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                                readonly uniqueItems: true;
+                            }];
+                        };
+                        readonly skipInlineCode: {
+                            readonly type: "boolean";
+                        };
+                        readonly tabWidth: {
+                            readonly type: "integer";
+                            readonly minimum: 1;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly skipCode: true;
+                    readonly skipInlineCode: true;
+                    readonly tabWidth: 4;
+                }];
+                readonly messages: {
+                    readonly noTab: "Tab character is not allowed. Please use spaces instead.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    skipCode: boolean | string[];
+                    skipInlineCode: boolean;
+                    tabWidth: number;
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "noTab";
+            }>) => {
+                code(node: import("mdast").Code): void;
+                inlineCode(node: import("mdast").InlineCode): void;
+                'root:exit'(): void;
+            };
+        };
+        'no-url-trailing-slash': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Disallow URL trailing slash";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: false;
+                };
+                readonly messages: {
+                    readonly noUrlTrailingSlash: "URL trailing slash is not allowed.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [];
+                Node: import("mdast").Node;
+                MessageIds: "noUrlTrailingSlash";
+            }>) => {
+                'link, image, definition'(node: import("mdast").Link | import("mdast").Image | import("mdast").Definition): void;
+                html(node: import("mdast").Html): void;
+            };
+        };
+        'require-heading-id': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Enforce the use of heading IDs";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: false;
+                };
+                readonly fixable: "code";
+                readonly schema: [{
+                    readonly enum: ["always", "never"];
+                }, {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly leftDelimiter: {
+                            readonly type: "string";
+                        };
+                        readonly rightDelimiter: {
+                            readonly type: "string";
+                        };
+                        readonly allowDepths: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly enum: [1, 2, 3, 4, 5, 6];
+                            };
+                            readonly uniqueItems: true;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: ["always", {
+                    readonly leftDelimiter: "{";
+                    readonly rightDelimiter: "}";
+                    readonly allowDepths: [];
+                }];
+                readonly messages: {
+                    readonly headingIdAlways: "Headings should have an ID attribute.";
+                    readonly headingIdNever: "Headings should not have an ID attribute. Remove the `{{ headingId }}`.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: ["always" | "never", {
+                    leftDelimiter: string;
+                    rightDelimiter: string;
+                    allowDepths: import("mdast").Heading["depth"][];
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "headingIdAlways" | "headingIdNever";
+            }>) => {
+                heading(node: import("mdast").Heading): void;
+            };
+        };
+        'require-image-title': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Enforce the use of title attribute for images";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: false;
+                };
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly allowDefinitions: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly allowDefinitions: ["//"];
+                }];
+                readonly messages: {
+                    readonly requireImageTitle: "Images should have a title attribute.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    allowDefinitions: string[];
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "requireImageTitle";
+            }>) => {
+                image(node: import("mdast").Image): void;
+                html(node: import("mdast").Html): void;
+                imageReference(node: import("mdast").ImageReference): void;
+                definition(node: import("mdast").Definition): void;
+                'root:exit'(): void;
+            };
+        };
+        'require-link-title': {
+            readonly meta: {
+                readonly type: "problem";
+                readonly docs: {
+                    readonly description: "Enforce the use of title attribute for links";
+                    readonly url: string;
+                    readonly recommended: false;
+                    readonly stylistic: false;
+                };
+                readonly schema: [{
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly allowDefinitions: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                            readonly uniqueItems: true;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+                readonly defaultOptions: [{
+                    readonly allowDefinitions: ["//"];
+                }];
+                readonly messages: {
+                    readonly requireLinkTitle: "Links should have a title attribute.";
+                };
+                readonly language: "markdown";
+                readonly dialects: ["commonmark", "gfm"];
+            };
+            readonly create: (context: import("@eslint/core").RuleContext<{
+                LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+                Code: import("@eslint/markdown").MarkdownSourceCode;
+                RuleOptions: [{
+                    allowDefinitions: string[];
+                }];
+                Node: import("mdast").Node;
+                MessageIds: "requireLinkTitle";
+            }>) => {
+                link(node: import("mdast").Link): void;
+                html(node: import("mdast").Html): void;
+                linkReference(node: import("mdast").LinkReference): void;
+                definition(node: import("mdast").Definition): void;
+                'root:exit'(): void;
+            };
+        };
+    };
+    readonly configs: {
+        readonly all: ReturnType<typeof all>;
+        readonly base: ReturnType<typeof base>;
+        readonly recommended: ReturnType<typeof recommended>;
+        readonly stylistic: ReturnType<typeof stylistic>;
+    };
+};
 export default plugin;
-declare namespace plugin {
-    export namespace meta {
-        export { name };
-        export { version };
-    }
-    export { rules };
-    export namespace configs {
-        const all: ReturnType<typeof import("./configs/all.js").default>;
-        const base: ReturnType<typeof import("./configs/base.js").default>;
-        const recommended: ReturnType<typeof import("./configs/recommended.js").default>;
-        const stylistic: ReturnType<typeof import("./configs/stylistic.js").default>;
-    }
-}
-import { PKG_NAME as name } from './core/constants.js';
-import { PKG_VERSION as version } from './core/constants.js';
-import rules from './rules/index.js';