@kazupon/eslint-config 0.7.0 → 0.9.0

package/dist/types/gens/yml.d.cts

@@ -0,0 +1,375 @@
+import type { Linter } from 'eslint';
+export interface YmlRules {
+    /**
+     * require or disallow block style mappings.
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/block-mapping.html
+     */
+    'yml/block-mapping'?: Linter.RuleEntry<YmlBlockMapping>;
+    /**
+     * enforce consistent line breaks after `:` indicator
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/block-mapping-colon-indicator-newline.html
+     */
+    'yml/block-mapping-colon-indicator-newline'?: Linter.RuleEntry<YmlBlockMappingColonIndicatorNewline>;
+    /**
+     * enforce consistent line breaks after `?` indicator
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/block-mapping-question-indicator-newline.html
+     */
+    'yml/block-mapping-question-indicator-newline'?: Linter.RuleEntry<YmlBlockMappingQuestionIndicatorNewline>;
+    /**
+     * require or disallow block style sequences.
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/block-sequence.html
+     */
+    'yml/block-sequence'?: Linter.RuleEntry<YmlBlockSequence>;
+    /**
+     * enforce consistent line breaks after `-` indicator
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/block-sequence-hyphen-indicator-newline.html
+     */
+    'yml/block-sequence-hyphen-indicator-newline'?: Linter.RuleEntry<YmlBlockSequenceHyphenIndicatorNewline>;
+    /**
+     * enforce YAML file extension
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/file-extension.html
+     */
+    'yml/file-extension'?: Linter.RuleEntry<YmlFileExtension>;
+    /**
+     * enforce consistent line breaks inside braces
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/flow-mapping-curly-newline.html
+     */
+    'yml/flow-mapping-curly-newline'?: Linter.RuleEntry<YmlFlowMappingCurlyNewline>;
+    /**
+     * enforce consistent spacing inside braces
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/flow-mapping-curly-spacing.html
+     */
+    'yml/flow-mapping-curly-spacing'?: Linter.RuleEntry<YmlFlowMappingCurlySpacing>;
+    /**
+     * enforce linebreaks after opening and before closing flow sequence brackets
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/flow-sequence-bracket-newline.html
+     */
+    'yml/flow-sequence-bracket-newline'?: Linter.RuleEntry<YmlFlowSequenceBracketNewline>;
+    /**
+     * enforce consistent spacing inside flow sequence brackets
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/flow-sequence-bracket-spacing.html
+     */
+    'yml/flow-sequence-bracket-spacing'?: Linter.RuleEntry<YmlFlowSequenceBracketSpacing>;
+    /**
+     * enforce consistent indentation
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/indent.html
+     */
+    'yml/indent'?: Linter.RuleEntry<YmlIndent>;
+    /**
+     * enforce naming convention to key names
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/key-name-casing.html
+     */
+    'yml/key-name-casing'?: Linter.RuleEntry<YmlKeyNameCasing>;
+    /**
+     * enforce consistent spacing between keys and values in mapping pairs
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/key-spacing.html
+     */
+    'yml/key-spacing'?: Linter.RuleEntry<YmlKeySpacing>;
+    /**
+     * disallow empty document
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-empty-document.html
+     */
+    'yml/no-empty-document'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow empty mapping keys
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-empty-key.html
+     */
+    'yml/no-empty-key'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow empty mapping values
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-empty-mapping-value.html
+     */
+    'yml/no-empty-mapping-value'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow empty sequence entries
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-empty-sequence-entry.html
+     */
+    'yml/no-empty-sequence-entry'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow irregular whitespace
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-irregular-whitespace.html
+     */
+    'yml/no-irregular-whitespace'?: Linter.RuleEntry<YmlNoIrregularWhitespace>;
+    /**
+     * disallow multiple empty lines
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-multiple-empty-lines.html
+     */
+    'yml/no-multiple-empty-lines'?: Linter.RuleEntry<YmlNoMultipleEmptyLines>;
+    /**
+     * disallow tabs for indentation.
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-tab-indent.html
+     */
+    'yml/no-tab-indent'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow trailing zeros for floats
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-trailing-zeros.html
+     */
+    'yml/no-trailing-zeros'?: Linter.RuleEntry<[]>;
+    /**
+     * require or disallow plain style scalar.
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/plain-scalar.html
+     */
+    'yml/plain-scalar'?: Linter.RuleEntry<YmlPlainScalar>;
+    /**
+     * enforce the consistent use of either double, or single quotes
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/quotes.html
+     */
+    'yml/quotes'?: Linter.RuleEntry<YmlQuotes>;
+    /**
+     * disallow mapping keys other than strings
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/require-string-key.html
+     */
+    'yml/require-string-key'?: Linter.RuleEntry<[]>;
+    /**
+     * require mapping keys to be sorted
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/sort-keys.html
+     */
+    'yml/sort-keys'?: Linter.RuleEntry<YmlSortKeys>;
+    /**
+     * require sequence values to be sorted
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/sort-sequence-values.html
+     */
+    'yml/sort-sequence-values'?: Linter.RuleEntry<YmlSortSequenceValues>;
+    /**
+     * enforce consistent spacing after the `#` in a comment
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/spaced-comment.html
+     */
+    'yml/spaced-comment'?: Linter.RuleEntry<YmlSpacedComment>;
+    /**
+     * disallow parsing errors in Vue custom blocks
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/vue-custom-block/no-parsing-error.html
+     */
+    'yml/vue-custom-block/no-parsing-error'?: Linter.RuleEntry<[]>;
+}
+type YmlBlockMapping = [] | [
+    (("always" | "never") | {
+        singleline?: ("always" | "never" | "ignore");
+        multiline?: ("always" | "never" | "ignore");
+    })
+];
+type YmlBlockMappingColonIndicatorNewline = [] | [("always" | "never")];
+type YmlBlockMappingQuestionIndicatorNewline = [] | [("always" | "never")];
+type YmlBlockSequence = [] | [
+    (("always" | "never") | {
+        singleline?: ("always" | "never" | "ignore");
+        multiline?: ("always" | "never" | "ignore");
+    })
+];
+type YmlBlockSequenceHyphenIndicatorNewline = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        nestedHyphen?: ("always" | "never");
+        blockMapping?: ("always" | "never");
+    }
+];
+type YmlFileExtension = [] | [
+    {
+        extension?: ("yaml" | "yml");
+        caseSensitive?: boolean;
+    }
+];
+type YmlFlowMappingCurlyNewline = [] | [
+    (("always" | "never") | {
+        multiline?: boolean;
+        minProperties?: number;
+        consistent?: boolean;
+    })
+];
+type YmlFlowMappingCurlySpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        arraysInObjects?: boolean;
+        objectsInObjects?: boolean;
+    }
+];
+type YmlFlowSequenceBracketNewline = [] | [
+    (("always" | "never" | "consistent") | {
+        multiline?: boolean;
+        minItems?: (number | null);
+    })
+];
+type YmlFlowSequenceBracketSpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        singleValue?: boolean;
+        objectsInArrays?: boolean;
+        arraysInArrays?: boolean;
+    }
+];
+type YmlIndent = [] | [number] | [
+    number,
+    {
+        indentBlockSequences?: boolean;
+        indicatorValueIndent?: number;
+    }
+];
+type YmlKeyNameCasing = [] | [
+    {
+        camelCase?: boolean;
+        PascalCase?: boolean;
+        SCREAMING_SNAKE_CASE?: boolean;
+        "kebab-case"?: boolean;
+        snake_case?: boolean;
+        ignores?: string[];
+    }
+];
+type YmlKeySpacing = [] | [
+    ({
+        align?: (("colon" | "value") | {
+            on?: ("colon" | "value");
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        });
+        mode?: ("strict" | "minimum");
+        beforeColon?: boolean;
+        afterColon?: boolean;
+    } | {
+        singleLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        multiLine?: {
+            align?: (("colon" | "value") | {
+                on?: ("colon" | "value");
+                mode?: ("strict" | "minimum");
+                beforeColon?: boolean;
+                afterColon?: boolean;
+            });
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+    } | {
+        singleLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        multiLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        align?: {
+            on?: ("colon" | "value");
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+    })
+];
+type YmlNoIrregularWhitespace = [] | [
+    {
+        skipComments?: boolean;
+        skipQuotedScalars?: boolean;
+    }
+];
+type YmlNoMultipleEmptyLines = [] | [
+    {
+        max: number;
+        maxEOF?: number;
+        maxBOF?: number;
+    }
+];
+type YmlPlainScalar = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        ignorePatterns?: string[];
+    }
+];
+type YmlQuotes = [] | [
+    {
+        prefer?: ("double" | "single");
+        avoidEscape?: boolean;
+    }
+];
+type YmlSortKeys = ([
+    {
+        pathPattern: string;
+        hasProperties?: string[];
+        order: ((string | {
+            keyPattern?: string;
+            order?: {
+                type?: ("asc" | "desc");
+                caseSensitive?: boolean;
+                natural?: boolean;
+            };
+        })[] | {
+            type?: ("asc" | "desc");
+            caseSensitive?: boolean;
+            natural?: boolean;
+        });
+        minKeys?: number;
+        allowLineSeparatedGroups?: boolean;
+    },
+    ...({
+        pathPattern: string;
+        hasProperties?: string[];
+        order: ((string | {
+            keyPattern?: string;
+            order?: {
+                type?: ("asc" | "desc");
+                caseSensitive?: boolean;
+                natural?: boolean;
+            };
+        })[] | {
+            type?: ("asc" | "desc");
+            caseSensitive?: boolean;
+            natural?: boolean;
+        });
+        minKeys?: number;
+        allowLineSeparatedGroups?: boolean;
+    })[]
+] | [] | [("asc" | "desc")] | [
+    ("asc" | "desc"),
+    {
+        caseSensitive?: boolean;
+        natural?: boolean;
+        minKeys?: number;
+        allowLineSeparatedGroups?: boolean;
+    }
+]);
+type YmlSortSequenceValues = [
+    {
+        pathPattern: string;
+        order: ((string | {
+            valuePattern?: string;
+            order?: {
+                type?: ("asc" | "desc");
+                caseSensitive?: boolean;
+                natural?: boolean;
+            };
+        })[] | {
+            type?: ("asc" | "desc");
+            caseSensitive?: boolean;
+            natural?: boolean;
+        });
+        minValues?: number;
+    },
+    ...({
+        pathPattern: string;
+        order: ((string | {
+            valuePattern?: string;
+            order?: {
+                type?: ("asc" | "desc");
+                caseSensitive?: boolean;
+                natural?: boolean;
+            };
+        })[] | {
+            type?: ("asc" | "desc");
+            caseSensitive?: boolean;
+            natural?: boolean;
+        });
+        minValues?: number;
+    })[]
+];
+type YmlSpacedComment = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        exceptions?: string[];
+        markers?: string[];
+    }
+];
+export {};