slopless 0.2.11 → 0.2.13

package/dist/adapters/textlint/report.d.ts

@@ -0,0 +1,35 @@
+import type { TxtNode } from "@textlint/ast-node-types";
+import type { TextlintRuleContext } from "@textlint/types";
+import type { TextUnit } from "../../rules/types.js";
+import type { RuleId, SourceRange } from "../../rules/types.js";
+import type { RuleReport } from "../../reporting/types.js";
+export declare function emitTextlintReport(context: Readonly<TextlintRuleContext>, unitsById: ReadonlyMap<string, TextUnit>, report: RuleReport): void;
+export declare function emitTextlintReports(context: Readonly<TextlintRuleContext>, unitsById: ReadonlyMap<string, TextUnit>, reports: readonly RuleReport[]): void;
+type TextlintDetectionInput = {
+    readonly data?: Readonly<Record<string, boolean | number | string>>;
+    readonly evidence: string;
+    readonly label: string;
+    readonly message: string;
+    readonly range: SourceRange;
+    readonly ruleId: RuleId;
+    readonly unit: TextUnit;
+};
+type TextlintFindingInput = {
+    readonly data?: Readonly<Record<string, boolean | number | string>>;
+    readonly evidence?: string;
+    readonly label?: string;
+    readonly message: string;
+    readonly node: TxtNode;
+    readonly range: SourceRange;
+    readonly ruleId: RuleId;
+};
+type TextlintNodeFindingInput = {
+    readonly message: string;
+    readonly node: TxtNode;
+    readonly ruleId: RuleId;
+};
+export declare function emitTextlintDetection(context: Readonly<TextlintRuleContext>, input: TextlintDetectionInput): void;
+export declare function emitTextlintFinding(context: Readonly<TextlintRuleContext>, input: TextlintFindingInput): void;
+export declare function emitTextlintNodeFinding(context: Readonly<TextlintRuleContext>, input: TextlintNodeFindingInput): void;
+export {};
+//# sourceMappingURL=report.d.ts.map

package/dist/adapters/textlint/rule.d.ts

@@ -0,0 +1,11 @@
+import type { TxtDocumentNode } from "@textlint/ast-node-types";
+import type { TextlintRuleContext, TextlintRuleModule } from "@textlint/types";
+import type { TextUnit } from "../../rules/types.js";
+import type { RuleDefinition } from "../../reporting/types.js";
+type TextlintUnitProvider<Options extends object> = (document: TxtDocumentNode, context: Readonly<TextlintRuleContext>, options: Readonly<Options> | undefined) => readonly TextUnit[];
+type TextlintRuleDefinition<Options extends object> = RuleDefinition<Options> & {
+    readonly units: TextlintUnitProvider<Options>;
+};
+export declare function defineTextlintRule<Options extends object = Record<string, never>>(definition: TextlintRuleDefinition<Options>): TextlintRuleModule<Options>;
+export {};
+//# sourceMappingURL=rule.d.ts.map

package/dist/adapters/textlint/units.d.ts

@@ -0,0 +1,14 @@
+import type { TxtDocumentNode, TxtNode } from "@textlint/ast-node-types";
+import type { TextUnit } from "../../rules/types.js";
+export declare function documentUnit(document: TxtDocumentNode): TextUnit;
+export declare function paragraphSequenceUnit(document: TxtDocumentNode): TextUnit;
+export declare function paragraphUnits(document: TxtDocumentNode): TextUnit[];
+export declare function sentenceUnits(document: TxtDocumentNode): TextUnit[];
+export declare function sectionFirstSentenceUnits(document: TxtDocumentNode): TextUnit[];
+export declare function sectionLastSentenceUnits(document: TxtDocumentNode): TextUnit[];
+export declare function headingUnits(document: TxtDocumentNode, ignoredAncestorTypes?: readonly string[]): TextUnit[];
+export declare function allParagraphUnits(document: TxtDocumentNode, ignoredAncestorTypes?: readonly string[]): TextUnit[];
+export declare function strUnits(document: TxtDocumentNode, ignoredAncestorTypes?: readonly string[]): TextUnit[];
+export declare function linkUnits(document: TxtDocumentNode, ignoredAncestorTypes?: readonly string[]): TextUnit[];
+export declare function textUnitForNode(id: string, kind: TextUnit["kind"], node: TxtNode, text: string): TextUnit;
+//# sourceMappingURL=units.d.ts.map

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,348 @@
+export declare const rules: {
+    "hedge-stacking": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "llm-vocabulary-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "llm-vocabulary": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "prohibited-words": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    simplicity: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "recommended-terms": import("@textlint/types").TextlintRuleModule<{
+        readonly allowInflections?: boolean;
+        readonly minCount?: number;
+        readonly terms?: readonly string[];
+    }>;
+    "required-terms": import("@textlint/types").TextlintRuleModule<{
+        readonly terms?: readonly string[];
+    }>;
+    "demonstrative-emphasis": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "empty-emphasis": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "fragment-stacking": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "repeated-predicate-end": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "repeated-sentence-starts": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "triple-repeat": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "response-wrapper": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "boilerplate-framing": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "formal-transition-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "generic-signposting": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "lesson-framing": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "llm-openers": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "observer-guidance": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "softening-language": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "universalizing-claims": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "blame-reframe": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "contrastive-aphorism": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "negation-reframe": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "affirmation-closers": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "boilerplate-conclusion": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "false-question": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "summative-closer": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "authority-padding": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "uncited-authority": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "semantic-thinness": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    cliches: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "corporate-speak": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "humble-bragger": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "jargon-faker": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "llm-disclaimer": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "prohibited-phrases": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    redundancy: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "skunked-terms": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    uncomparables: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    wordiness: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "artifact-placeholders": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "colon-dramatic": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "em-dashes": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "exclamation-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "fake-timestamps": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "hidden-unicode-controls": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "sentence-case": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "smart-quotes": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "body-action-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "empty-beat": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "emotion-telling": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "flat-action-cadence": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "low-information-beat-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "perception-verb-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "narrative-cliches": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "avg-sentence-length": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "coleman-liau": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "flesch-kincaid": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "gunning-fog": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "paragraph-length": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "word-repetition": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "academic-boilerplate": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "academic-formula-frames": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "tortured-phrases": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+export declare const presets: {
+    everything: {
+        rules: {
+            "affirmation-closers": boolean;
+            "artifact-placeholders": boolean;
+            "authority-padding": boolean;
+            "avg-sentence-length": boolean;
+            "blame-reframe": boolean;
+            "body-action-density": boolean;
+            "boilerplate-conclusion": boolean;
+            "boilerplate-framing": boolean;
+            cliches: boolean;
+            "colon-dramatic": boolean;
+            "coleman-liau": boolean;
+            "corporate-speak": boolean;
+            "contrastive-aphorism": boolean;
+            "demonstrative-emphasis": boolean;
+            "em-dashes": boolean;
+            "empty-emphasis": boolean;
+            "exclamation-density": boolean;
+            "fake-timestamps": boolean;
+            "false-question": boolean;
+            "flat-action-cadence": boolean;
+            "formal-transition-density": boolean;
+            "flesch-kincaid": boolean;
+            "fragment-stacking": boolean;
+            "gunning-fog": boolean;
+            "hedge-stacking": boolean;
+            "hidden-unicode-controls": boolean;
+            "humble-bragger": boolean;
+            "jargon-faker": boolean;
+            "generic-signposting": boolean;
+            "lesson-framing": boolean;
+            "llm-disclaimer": boolean;
+            "llm-openers": boolean;
+            "llm-vocabulary-density": boolean;
+            "llm-vocabulary": boolean;
+            "low-information-beat-density": boolean;
+            "negation-reframe": boolean;
+            "narrative-cliches": boolean;
+            "observer-guidance": boolean;
+            "paragraph-length": boolean;
+            "perception-verb-density": boolean;
+            "prohibited-phrases": boolean;
+            "prohibited-words": boolean;
+            "recommended-terms": boolean;
+            redundancy: boolean;
+            "repeated-predicate-end": boolean;
+            "repeated-sentence-starts": boolean;
+            "response-wrapper": boolean;
+            "required-terms": boolean;
+            "sentence-case": boolean;
+            "semantic-thinness": boolean;
+            simplicity: boolean;
+            "skunked-terms": boolean;
+            "softening-language": boolean;
+            "smart-quotes": boolean;
+            "summative-closer": boolean;
+            "triple-repeat": boolean;
+            "tortured-phrases": boolean;
+            "uncited-authority": boolean;
+            uncomparables: boolean;
+            "universalizing-claims": boolean;
+            "word-repetition": boolean;
+            wordiness: boolean;
+        };
+    };
+};
+export declare const rulesConfig: {
+    "affirmation-closers": boolean;
+    "artifact-placeholders": boolean;
+    "authority-padding": boolean;
+    "avg-sentence-length": boolean;
+    "blame-reframe": boolean;
+    "body-action-density": boolean;
+    "boilerplate-conclusion": boolean;
+    "boilerplate-framing": boolean;
+    cliches: boolean;
+    "colon-dramatic": boolean;
+    "coleman-liau": boolean;
+    "corporate-speak": boolean;
+    "contrastive-aphorism": boolean;
+    "demonstrative-emphasis": boolean;
+    "em-dashes": boolean;
+    "empty-emphasis": boolean;
+    "exclamation-density": boolean;
+    "fake-timestamps": boolean;
+    "false-question": boolean;
+    "flat-action-cadence": boolean;
+    "formal-transition-density": boolean;
+    "flesch-kincaid": boolean;
+    "fragment-stacking": boolean;
+    "gunning-fog": boolean;
+    "hedge-stacking": boolean;
+    "hidden-unicode-controls": boolean;
+    "humble-bragger": boolean;
+    "jargon-faker": boolean;
+    "generic-signposting": boolean;
+    "lesson-framing": boolean;
+    "llm-disclaimer": boolean;
+    "llm-openers": boolean;
+    "llm-vocabulary-density": boolean;
+    "llm-vocabulary": boolean;
+    "low-information-beat-density": boolean;
+    "negation-reframe": boolean;
+    "narrative-cliches": boolean;
+    "observer-guidance": boolean;
+    "paragraph-length": boolean;
+    "perception-verb-density": boolean;
+    "prohibited-phrases": boolean;
+    "prohibited-words": boolean;
+    "recommended-terms": boolean;
+    redundancy: boolean;
+    "repeated-predicate-end": boolean;
+    "repeated-sentence-starts": boolean;
+    "response-wrapper": boolean;
+    "required-terms": boolean;
+    "sentence-case": boolean;
+    "semantic-thinness": boolean;
+    simplicity: boolean;
+    "skunked-terms": boolean;
+    "softening-language": boolean;
+    "smart-quotes": boolean;
+    "summative-closer": boolean;
+    "triple-repeat": boolean;
+    "tortured-phrases": boolean;
+    "uncited-authority": boolean;
+    uncomparables: boolean;
+    "universalizing-claims": boolean;
+    "word-repetition": boolean;
+    wordiness: boolean;
+};
+declare const _default: {
+    rules: {
+        "hedge-stacking": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "llm-vocabulary-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "llm-vocabulary": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "prohibited-words": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        simplicity: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "recommended-terms": import("@textlint/types").TextlintRuleModule<{
+            readonly allowInflections?: boolean;
+            readonly minCount?: number;
+            readonly terms?: readonly string[];
+        }>;
+        "required-terms": import("@textlint/types").TextlintRuleModule<{
+            readonly terms?: readonly string[];
+        }>;
+        "demonstrative-emphasis": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "empty-emphasis": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "fragment-stacking": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "repeated-predicate-end": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "repeated-sentence-starts": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "triple-repeat": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "response-wrapper": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "boilerplate-framing": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "formal-transition-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "generic-signposting": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "lesson-framing": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "llm-openers": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "observer-guidance": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "softening-language": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "universalizing-claims": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "blame-reframe": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "contrastive-aphorism": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "negation-reframe": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "affirmation-closers": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "boilerplate-conclusion": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "false-question": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "summative-closer": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "authority-padding": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "uncited-authority": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "semantic-thinness": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        cliches: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "corporate-speak": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "humble-bragger": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "jargon-faker": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "llm-disclaimer": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "prohibited-phrases": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        redundancy: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "skunked-terms": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        uncomparables: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        wordiness: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "artifact-placeholders": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "colon-dramatic": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "em-dashes": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "exclamation-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "fake-timestamps": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "hidden-unicode-controls": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "sentence-case": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "smart-quotes": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "body-action-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "empty-beat": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "emotion-telling": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "flat-action-cadence": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "low-information-beat-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "perception-verb-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "narrative-cliches": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "avg-sentence-length": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "coleman-liau": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "flesch-kincaid": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "gunning-fog": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "paragraph-length": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "word-repetition": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "academic-boilerplate": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "academic-formula-frames": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+        "tortured-phrases": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    };
+    rulesConfig: {
+        "affirmation-closers": boolean;
+        "artifact-placeholders": boolean;
+        "authority-padding": boolean;
+        "avg-sentence-length": boolean;
+        "blame-reframe": boolean;
+        "body-action-density": boolean;
+        "boilerplate-conclusion": boolean;
+        "boilerplate-framing": boolean;
+        cliches: boolean;
+        "colon-dramatic": boolean;
+        "coleman-liau": boolean;
+        "corporate-speak": boolean;
+        "contrastive-aphorism": boolean;
+        "demonstrative-emphasis": boolean;
+        "em-dashes": boolean;
+        "empty-emphasis": boolean;
+        "exclamation-density": boolean;
+        "fake-timestamps": boolean;
+        "false-question": boolean;
+        "flat-action-cadence": boolean;
+        "formal-transition-density": boolean;
+        "flesch-kincaid": boolean;
+        "fragment-stacking": boolean;
+        "gunning-fog": boolean;
+        "hedge-stacking": boolean;
+        "hidden-unicode-controls": boolean;
+        "humble-bragger": boolean;
+        "jargon-faker": boolean;
+        "generic-signposting": boolean;
+        "lesson-framing": boolean;
+        "llm-disclaimer": boolean;
+        "llm-openers": boolean;
+        "llm-vocabulary-density": boolean;
+        "llm-vocabulary": boolean;
+        "low-information-beat-density": boolean;
+        "negation-reframe": boolean;
+        "narrative-cliches": boolean;
+        "observer-guidance": boolean;
+        "paragraph-length": boolean;
+        "perception-verb-density": boolean;
+        "prohibited-phrases": boolean;
+        "prohibited-words": boolean;
+        "recommended-terms": boolean;
+        redundancy: boolean;
+        "repeated-predicate-end": boolean;
+        "repeated-sentence-starts": boolean;
+        "response-wrapper": boolean;
+        "required-terms": boolean;
+        "sentence-case": boolean;
+        "semantic-thinness": boolean;
+        simplicity: boolean;
+        "skunked-terms": boolean;
+        "softening-language": boolean;
+        "smart-quotes": boolean;
+        "summative-closer": boolean;
+        "triple-repeat": boolean;
+        "tortured-phrases": boolean;
+        "uncited-authority": boolean;
+        uncomparables: boolean;
+        "universalizing-claims": boolean;
+        "word-repetition": boolean;
+        wordiness: boolean;
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/presets/everything.d.ts

@@ -0,0 +1,67 @@
+export declare const everything: {
+    rules: {
+        "affirmation-closers": boolean;
+        "artifact-placeholders": boolean;
+        "authority-padding": boolean;
+        "avg-sentence-length": boolean;
+        "blame-reframe": boolean;
+        "body-action-density": boolean;
+        "boilerplate-conclusion": boolean;
+        "boilerplate-framing": boolean;
+        cliches: boolean;
+        "colon-dramatic": boolean;
+        "coleman-liau": boolean;
+        "corporate-speak": boolean;
+        "contrastive-aphorism": boolean;
+        "demonstrative-emphasis": boolean;
+        "em-dashes": boolean;
+        "empty-emphasis": boolean;
+        "exclamation-density": boolean;
+        "fake-timestamps": boolean;
+        "false-question": boolean;
+        "flat-action-cadence": boolean;
+        "formal-transition-density": boolean;
+        "flesch-kincaid": boolean;
+        "fragment-stacking": boolean;
+        "gunning-fog": boolean;
+        "hedge-stacking": boolean;
+        "hidden-unicode-controls": boolean;
+        "humble-bragger": boolean;
+        "jargon-faker": boolean;
+        "generic-signposting": boolean;
+        "lesson-framing": boolean;
+        "llm-disclaimer": boolean;
+        "llm-openers": boolean;
+        "llm-vocabulary-density": boolean;
+        "llm-vocabulary": boolean;
+        "low-information-beat-density": boolean;
+        "negation-reframe": boolean;
+        "narrative-cliches": boolean;
+        "observer-guidance": boolean;
+        "paragraph-length": boolean;
+        "perception-verb-density": boolean;
+        "prohibited-phrases": boolean;
+        "prohibited-words": boolean;
+        "recommended-terms": boolean;
+        redundancy: boolean;
+        "repeated-predicate-end": boolean;
+        "repeated-sentence-starts": boolean;
+        "response-wrapper": boolean;
+        "required-terms": boolean;
+        "sentence-case": boolean;
+        "semantic-thinness": boolean;
+        simplicity: boolean;
+        "skunked-terms": boolean;
+        "softening-language": boolean;
+        "smart-quotes": boolean;
+        "summative-closer": boolean;
+        "triple-repeat": boolean;
+        "tortured-phrases": boolean;
+        "uncited-authority": boolean;
+        uncomparables: boolean;
+        "universalizing-claims": boolean;
+        "word-repetition": boolean;
+        wordiness: boolean;
+    };
+};
+//# sourceMappingURL=everything.d.ts.map

package/dist/registries/academic-slop.d.ts

@@ -0,0 +1,6 @@
+export declare const academicSlopRules: {
+    "academic-boilerplate": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "academic-formula-frames": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "tortured-phrases": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=academic-slop.d.ts.map

package/dist/registries/metrics.d.ts

@@ -0,0 +1,9 @@
+export declare const metricRules: {
+    "avg-sentence-length": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "coleman-liau": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "flesch-kincaid": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "gunning-fog": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "paragraph-length": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "word-repetition": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=metrics.d.ts.map

package/dist/registries/narrative-slop.d.ts

@@ -0,0 +1,10 @@
+export declare const narrativeSlopRules: {
+    "body-action-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "empty-beat": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "emotion-telling": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "flat-action-cadence": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "low-information-beat-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "perception-verb-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "narrative-cliches": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=narrative-slop.d.ts.map

package/dist/registries/orthography.d.ts

@@ -0,0 +1,11 @@
+export declare const orthographyRules: {
+    "artifact-placeholders": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "colon-dramatic": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "em-dashes": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "exclamation-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "fake-timestamps": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "hidden-unicode-controls": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "sentence-case": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "smart-quotes": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=orthography.d.ts.map

package/dist/registries/phrases.d.ts

@@ -0,0 +1,13 @@
+export declare const phraseRules: {
+    cliches: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "corporate-speak": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "humble-bragger": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "jargon-faker": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "llm-disclaimer": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "prohibited-phrases": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    redundancy: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "skunked-terms": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    uncomparables: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    wordiness: import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=phrases.d.ts.map

package/dist/registries/semantic-thinness.d.ts

@@ -0,0 +1,4 @@
+export declare const semanticThinnessRules: {
+    "semantic-thinness": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=semantic-thinness.d.ts.map

package/dist/registries/syntactic-patterns/authority.d.ts

@@ -0,0 +1,5 @@
+export declare const authorityRules: {
+    "authority-padding": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "uncited-authority": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=authority.d.ts.map

package/dist/registries/syntactic-patterns/closers.d.ts

@@ -0,0 +1,7 @@
+export declare const closerRules: {
+    "affirmation-closers": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "boilerplate-conclusion": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "false-question": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "summative-closer": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=closers.d.ts.map

package/dist/registries/syntactic-patterns/contrast.d.ts

@@ -0,0 +1,6 @@
+export declare const contrastRules: {
+    "blame-reframe": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "contrastive-aphorism": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "negation-reframe": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=contrast.d.ts.map

package/dist/registries/syntactic-patterns/generalization.d.ts

@@ -0,0 +1,5 @@
+export declare const generalizationRules: {
+    "softening-language": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "universalizing-claims": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=generalization.d.ts.map

package/dist/registries/syntactic-patterns/lead-ins.d.ts

@@ -0,0 +1,9 @@
+export declare const leadInRules: {
+    "boilerplate-framing": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "formal-transition-density": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "generic-signposting": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "lesson-framing": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "llm-openers": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "observer-guidance": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=lead-ins.d.ts.map

package/dist/registries/syntactic-patterns/llm-artifacts.d.ts

@@ -0,0 +1,4 @@
+export declare const llmArtifactRules: {
+    "response-wrapper": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=llm-artifacts.d.ts.map

package/dist/registries/syntactic-patterns/repetition.d.ts

@@ -0,0 +1,9 @@
+export declare const repetitionRules: {
+    "demonstrative-emphasis": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "empty-emphasis": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "fragment-stacking": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "repeated-predicate-end": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "repeated-sentence-starts": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+    "triple-repeat": import("@textlint/types").TextlintRuleModule<Record<string, never>>;
+};
+//# sourceMappingURL=repetition.d.ts.map