@kazupon/eslint-config 0.7.0 → 0.9.0

package/dist/types/gens/jsonc.d.ts

@@ -0,0 +1,513 @@
+import type { Linter } from 'eslint';
+export interface JsoncRules {
+    /**
+     * enforce line breaks after opening and before closing array brackets
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/array-bracket-newline.html
+     */
+    'jsonc/array-bracket-newline'?: Linter.RuleEntry<JsoncArrayBracketNewline>;
+    /**
+     * disallow or enforce spaces inside of brackets
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/array-bracket-spacing.html
+     */
+    'jsonc/array-bracket-spacing'?: Linter.RuleEntry<JsoncArrayBracketSpacing>;
+    /**
+     * enforce line breaks between array elements
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/array-element-newline.html
+     */
+    'jsonc/array-element-newline'?: Linter.RuleEntry<JsoncArrayElementNewline>;
+    /**
+     * apply jsonc rules similar to your configured ESLint core rules
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/auto.html
+     */
+    'jsonc/auto'?: Linter.RuleEntry<[]>;
+    /**
+     * require or disallow trailing commas
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/comma-dangle.html
+     */
+    'jsonc/comma-dangle'?: Linter.RuleEntry<JsoncCommaDangle>;
+    /**
+     * enforce consistent comma style
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/comma-style.html
+     */
+    'jsonc/comma-style'?: Linter.RuleEntry<JsoncCommaStyle>;
+    /**
+     * enforce consistent indentation
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/indent.html
+     */
+    'jsonc/indent'?: Linter.RuleEntry<JsoncIndent>;
+    /**
+     * enforce naming convention to property key names
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/key-name-casing.html
+     */
+    'jsonc/key-name-casing'?: Linter.RuleEntry<JsoncKeyNameCasing>;
+    /**
+     * enforce consistent spacing between keys and values in object literal properties
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/key-spacing.html
+     */
+    'jsonc/key-spacing'?: Linter.RuleEntry<JsoncKeySpacing>;
+    /**
+     * disallow BigInt literals
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-bigint-literals.html
+     */
+    'jsonc/no-bigint-literals'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow binary expression
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-binary-expression.html
+     */
+    'jsonc/no-binary-expression'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow binary numeric literals
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-binary-numeric-literals.html
+     */
+    'jsonc/no-binary-numeric-literals'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow comments
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-comments.html
+     */
+    'jsonc/no-comments'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow duplicate keys in object literals
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-dupe-keys.html
+     */
+    'jsonc/no-dupe-keys'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow escape sequences in identifiers.
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-escape-sequence-in-identifier.html
+     */
+    'jsonc/no-escape-sequence-in-identifier'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow leading or trailing decimal points in numeric literals
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-floating-decimal.html
+     */
+    'jsonc/no-floating-decimal'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow hexadecimal numeric literals
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-hexadecimal-numeric-literals.html
+     */
+    'jsonc/no-hexadecimal-numeric-literals'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow Infinity
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-infinity.html
+     */
+    'jsonc/no-infinity'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow irregular whitespace
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-irregular-whitespace.html
+     */
+    'jsonc/no-irregular-whitespace'?: Linter.RuleEntry<JsoncNoIrregularWhitespace>;
+    /**
+     * disallow multiline strings
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-multi-str.html
+     */
+    'jsonc/no-multi-str'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow NaN
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-nan.html
+     */
+    'jsonc/no-nan'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow number property keys
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-number-props.html
+     */
+    'jsonc/no-number-props'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow numeric separators
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-numeric-separators.html
+     */
+    'jsonc/no-numeric-separators'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow legacy octal literals
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-octal.html
+     */
+    'jsonc/no-octal'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow octal escape sequences in string literals
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-octal-escape.html
+     */
+    'jsonc/no-octal-escape'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow octal numeric literals
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-octal-numeric-literals.html
+     */
+    'jsonc/no-octal-numeric-literals'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow parentheses around the expression
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-parenthesized.html
+     */
+    'jsonc/no-parenthesized'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow plus sign
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-plus-sign.html
+     */
+    'jsonc/no-plus-sign'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow RegExp literals
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-regexp-literals.html
+     */
+    'jsonc/no-regexp-literals'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow sparse arrays
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-sparse-arrays.html
+     */
+    'jsonc/no-sparse-arrays'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow template literals
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-template-literals.html
+     */
+    'jsonc/no-template-literals'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow `undefined`
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-undefined-value.html
+     */
+    'jsonc/no-undefined-value'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow Unicode code point escape sequences.
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-unicode-codepoint-escapes.html
+     */
+    'jsonc/no-unicode-codepoint-escapes'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow unnecessary escape usage
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-useless-escape.html
+     */
+    'jsonc/no-useless-escape'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce consistent line breaks inside braces
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/object-curly-newline.html
+     */
+    'jsonc/object-curly-newline'?: Linter.RuleEntry<JsoncObjectCurlyNewline>;
+    /**
+     * enforce consistent spacing inside braces
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/object-curly-spacing.html
+     */
+    'jsonc/object-curly-spacing'?: Linter.RuleEntry<JsoncObjectCurlySpacing>;
+    /**
+     * enforce placing object properties on separate lines
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/object-property-newline.html
+     */
+    'jsonc/object-property-newline'?: Linter.RuleEntry<JsoncObjectPropertyNewline>;
+    /**
+     * require quotes around object literal property names
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/quote-props.html
+     */
+    'jsonc/quote-props'?: Linter.RuleEntry<JsoncQuoteProps>;
+    /**
+     * enforce use of double or single quotes
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/quotes.html
+     */
+    'jsonc/quotes'?: Linter.RuleEntry<JsoncQuotes>;
+    /**
+     * require array values to be sorted
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/sort-array-values.html
+     */
+    'jsonc/sort-array-values'?: Linter.RuleEntry<JsoncSortArrayValues>;
+    /**
+     * require object keys to be sorted
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/sort-keys.html
+     */
+    'jsonc/sort-keys'?: Linter.RuleEntry<JsoncSortKeys>;
+    /**
+     * disallow spaces after unary operators
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/space-unary-ops.html
+     */
+    'jsonc/space-unary-ops'?: Linter.RuleEntry<JsoncSpaceUnaryOps>;
+    /**
+     * disallow invalid number for JSON
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/valid-json-number.html
+     */
+    'jsonc/valid-json-number'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow parsing errors in Vue custom blocks
+     * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/vue-custom-block/no-parsing-error.html
+     */
+    'jsonc/vue-custom-block/no-parsing-error'?: Linter.RuleEntry<[]>;
+}
+type JsoncArrayBracketNewline = [] | [
+    (("always" | "never" | "consistent") | {
+        multiline?: boolean;
+        minItems?: (number | null);
+    })
+];
+type JsoncArrayBracketSpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        singleValue?: boolean;
+        objectsInArrays?: boolean;
+        arraysInArrays?: boolean;
+    }
+];
+type JsoncArrayElementNewline = [] | [
+    (_JsoncArrayElementNewlineBasicConfig | {
+        ArrayExpression?: _JsoncArrayElementNewlineBasicConfig;
+        JSONArrayExpression?: _JsoncArrayElementNewlineBasicConfig;
+        ArrayPattern?: _JsoncArrayElementNewlineBasicConfig;
+    })
+];
+type _JsoncArrayElementNewlineBasicConfig = (("always" | "never" | "consistent") | {
+    multiline?: boolean;
+    minItems?: (number | null);
+});
+type JsoncCommaDangle = [] | [
+    (_JsoncCommaDangleValue | {
+        arrays?: _JsoncCommaDangleValueWithIgnore;
+        objects?: _JsoncCommaDangleValueWithIgnore;
+        imports?: _JsoncCommaDangleValueWithIgnore;
+        exports?: _JsoncCommaDangleValueWithIgnore;
+        functions?: _JsoncCommaDangleValueWithIgnore;
+    })
+];
+type _JsoncCommaDangleValue = ("always-multiline" | "always" | "never" | "only-multiline");
+type _JsoncCommaDangleValueWithIgnore = ("always-multiline" | "always" | "ignore" | "never" | "only-multiline");
+type JsoncCommaStyle = [] | [("first" | "last")] | [
+    ("first" | "last"),
+    {
+        exceptions?: {
+            [k: string]: boolean | undefined;
+        };
+    }
+];
+type JsoncIndent = [] | [("tab" | number)] | [
+    ("tab" | number),
+    {
+        SwitchCase?: number;
+        VariableDeclarator?: ((number | ("first" | "off")) | {
+            var?: (number | ("first" | "off"));
+            let?: (number | ("first" | "off"));
+            const?: (number | ("first" | "off"));
+        });
+        outerIIFEBody?: (number | "off");
+        MemberExpression?: (number | "off");
+        FunctionDeclaration?: {
+            parameters?: (number | ("first" | "off"));
+            body?: number;
+        };
+        FunctionExpression?: {
+            parameters?: (number | ("first" | "off"));
+            body?: number;
+        };
+        StaticBlock?: {
+            body?: number;
+        };
+        CallExpression?: {
+            arguments?: (number | ("first" | "off"));
+        };
+        ArrayExpression?: (number | ("first" | "off"));
+        ObjectExpression?: (number | ("first" | "off"));
+        ImportDeclaration?: (number | ("first" | "off"));
+        flatTernaryExpressions?: boolean;
+        offsetTernaryExpressions?: boolean;
+        ignoredNodes?: string[];
+        ignoreComments?: boolean;
+    }
+];
+type JsoncKeyNameCasing = [] | [
+    {
+        camelCase?: boolean;
+        PascalCase?: boolean;
+        SCREAMING_SNAKE_CASE?: boolean;
+        "kebab-case"?: boolean;
+        snake_case?: boolean;
+        ignores?: string[];
+    }
+];
+type JsoncKeySpacing = [] | [
+    ({
+        align?: (("colon" | "value") | {
+            mode?: ("strict" | "minimum");
+            on?: ("colon" | "value");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        });
+        mode?: ("strict" | "minimum");
+        beforeColon?: boolean;
+        afterColon?: boolean;
+    } | {
+        singleLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        multiLine?: {
+            align?: (("colon" | "value") | {
+                mode?: ("strict" | "minimum");
+                on?: ("colon" | "value");
+                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?: {
+            mode?: ("strict" | "minimum");
+            on?: ("colon" | "value");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+    })
+];
+type JsoncNoIrregularWhitespace = [] | [
+    {
+        skipComments?: boolean;
+        skipStrings?: boolean;
+        skipTemplates?: boolean;
+        skipRegExps?: boolean;
+        skipJSXText?: boolean;
+    }
+];
+type JsoncObjectCurlyNewline = [] | [
+    ((("always" | "never") | {
+        multiline?: boolean;
+        minProperties?: number;
+        consistent?: boolean;
+    }) | {
+        ObjectExpression?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+        ObjectPattern?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+        ImportDeclaration?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+        ExportDeclaration?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+    })
+];
+type JsoncObjectCurlySpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        arraysInObjects?: boolean;
+        objectsInObjects?: boolean;
+    }
+];
+type JsoncObjectPropertyNewline = [] | [
+    {
+        allowAllPropertiesOnSameLine?: boolean;
+        allowMultiplePropertiesPerLine?: boolean;
+    }
+];
+type JsoncQuoteProps = ([] | [("always" | "as-needed" | "consistent" | "consistent-as-needed")] | [] | [("always" | "as-needed" | "consistent" | "consistent-as-needed")] | [
+    ("always" | "as-needed" | "consistent" | "consistent-as-needed"),
+    {
+        keywords?: boolean;
+        unnecessary?: boolean;
+        numbers?: boolean;
+    }
+]);
+type JsoncQuotes = [] | [("single" | "double" | "backtick")] | [
+    ("single" | "double" | "backtick"),
+    ("avoid-escape" | {
+        avoidEscape?: boolean;
+        allowTemplateLiterals?: boolean;
+    })
+];
+type JsoncSortArrayValues = [
+    {
+        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 JsoncSortKeys = ([
+    {
+        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 JsoncSpaceUnaryOps = [] | [
+    {
+        words?: boolean;
+        nonwords?: boolean;
+        overrides?: {
+            [k: string]: boolean | undefined;
+        };
+    }
+];
+export {};

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

@@ -0,0 +1,2 @@
+export interface PrettierRules {
+}

package/dist/types/gens/prettier.d.ts

@@ -0,0 +1,2 @@
+export interface PrettierRules {
+}

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

@@ -0,0 +1,107 @@
+import type { Linter } from 'eslint';
+export interface PromiseRules {
+    /**
+     * Require returning inside each `then()` to create readable and reusable Promise chains.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/always-return.md
+     */
+    'promise/always-return'?: Linter.RuleEntry<PromiseAlwaysReturn>;
+    /**
+     * Disallow creating `new` promises outside of utility libs (use [pify][] instead).
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/avoid-new.md
+     */
+    'promise/avoid-new'?: Linter.RuleEntry<[]>;
+    /**
+     * Enforce the use of `catch()` on un-returned promises.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/catch-or-return.md
+     */
+    'promise/catch-or-return'?: Linter.RuleEntry<PromiseCatchOrReturn>;
+    /**
+     * Disallow calling `cb()` inside of a `then()` (use [nodeify][] instead).
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-callback-in-promise.md
+     */
+    'promise/no-callback-in-promise'?: Linter.RuleEntry<PromiseNoCallbackInPromise>;
+    /**
+     * Disallow creating new promises with paths that resolve multiple times.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-multiple-resolved.md
+     */
+    'promise/no-multiple-resolved'?: Linter.RuleEntry<[]>;
+    /**
+     * Require creating a `Promise` constructor before using it in an ES5 environment.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-native.md
+     */
+    'promise/no-native'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow nested `then()` or `catch()` statements.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-nesting.md
+     */
+    'promise/no-nesting'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow calling `new` on a Promise static method.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-new-statics.md
+     */
+    'promise/no-new-statics'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow using promises inside of callbacks.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-promise-in-callback.md
+     */
+    'promise/no-promise-in-callback'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow return statements in `finally()`.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-return-in-finally.md
+     */
+    'promise/no-return-in-finally'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow wrapping values in `Promise.resolve` or `Promise.reject` when not needed.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-return-wrap.md
+     */
+    'promise/no-return-wrap'?: Linter.RuleEntry<PromiseNoReturnWrap>;
+    /**
+     * Enforce consistent param names and ordering when creating new promises.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/param-names.md
+     */
+    'promise/param-names'?: Linter.RuleEntry<PromiseParamNames>;
+    /**
+     * Prefer async/await to the callback pattern.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-await-to-callbacks.md
+     */
+    'promise/prefer-await-to-callbacks'?: Linter.RuleEntry<[]>;
+    /**
+     * Prefer `await` to `then()`/`catch()`/`finally()` for reading Promise values.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-await-to-then.md
+     */
+    'promise/prefer-await-to-then'?: Linter.RuleEntry<[]>;
+    /**
+     * Enforces the proper number of arguments are passed to Promise functions.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/valid-params.md
+     */
+    'promise/valid-params'?: Linter.RuleEntry<[]>;
+}
+type PromiseAlwaysReturn = [] | [
+    {
+        ignoreLastCallback?: boolean;
+    }
+];
+type PromiseCatchOrReturn = [] | [
+    {
+        allowFinally?: boolean;
+        allowThen?: boolean;
+        terminationMethod?: (string | string[]);
+    }
+];
+type PromiseNoCallbackInPromise = [] | [
+    {
+        exceptions?: string[];
+    }
+];
+type PromiseNoReturnWrap = [] | [
+    {
+        allowReject?: boolean;
+    }
+];
+type PromiseParamNames = [] | [
+    {
+        resolvePattern?: string;
+        rejectPattern?: string;
+    }
+];
+export {};