eslint-config-vylda-typescript 5.0.0

package/rules/defaultTs.mjs

@@ -0,0 +1,654 @@
+// @ts-check
+import { bestPractices } from 'eslint-config-vylda-vanilla';
+
+/**
+ * @typedef {Object} noMagicNumbersRuleOptions
+ * @property {number[]} [ignore]
+ * @property {boolean} [ignoreArrayIndexes]
+ * @property {boolean} [ignoreDefaultValues]
+ * @property {boolean} [ignoreClassFieldInitialValues]
+ * @property {boolean} [ignoreEnums]
+ * @property {boolean} [ignoreNumericLiteralTypes]
+ * @property {boolean} [ignoreReadonlyClassProperties]
+ * @property {boolean} [enforceConst]
+ * @property {boolean} [detectObjects]
+ */
+
+/**
+ * @typedef {import('eslint').Linter.RuleSeverity} RuleSeverity
+ * @typedef {[RuleSeverity, noMagicNumbersRuleOptions]} noMagicNumbersRule
+ * @typedef {RuleSeverity | [RuleSeverity, ...any[]]} GenericRule
+ */
+
+const vanillaNoMagicNumbersRuleOptions = {
+  detectObjects: true,
+  enforceConst: true,
+  ignore: [-1, 0, 1],
+  ignoreArrayIndexes: true,
+  ignoreClassFieldInitialValues: false,
+  ignoreDefaultValues: false,
+};
+
+const tsNoMagicNumbersRuleOptions = {
+  ignoreEnums: true,
+  ignoreNumericLiteralTypes: true,
+  ignoreReadonlyClassProperties: true,
+  ignoreTypeIndexes: true,
+};
+
+/**
+ * Update no-magic-numbers rule to TS version
+ * @param {GenericRule} rule vanilla no-magic-numbers rule
+ * @returns {noMagicNumbersRule} typescript no-magic-numbers rule
+ */
+const updateNoMagicalNumbersRule = (rule) => {
+  if (!Array.isArray(rule)) {
+    return [
+      'error',
+      {
+        ...vanillaNoMagicNumbersRuleOptions,
+        ...tsNoMagicNumbersRuleOptions,
+      },
+    ];
+  }
+
+  const [severity, options] = rule;
+
+  if (typeof options === 'string') {
+    return [
+      severity,
+      {
+        ...vanillaNoMagicNumbersRuleOptions,
+        ...tsNoMagicNumbersRuleOptions,
+      },
+    ];
+  }
+
+  return [
+    severity,
+    {
+      ...vanillaNoMagicNumbersRuleOptions,
+      ...tsNoMagicNumbersRuleOptions,
+      ...options,
+    },
+  ];
+};
+
+/**
+ *
+ * @param  {import('eslint').Linter.RuleEntry} acc
+ * @param {any} config
+ * @returns  {import('eslint').Linter.RuleEntry}
+ */
+const noMagicNumbersRuleReducer = (acc, config) => {
+  const { rules } = config;
+
+  if (!rules) {
+    return acc;
+  }
+
+  const noMagicNumbersRule = rules['no-magic-numbers'];
+
+  if (!noMagicNumbersRule) {
+    return acc;
+  }
+
+  const updatedNoMagicalNumbersRule = updateNoMagicalNumbersRule(noMagicNumbersRule);
+
+  return updatedNoMagicalNumbersRule;
+};
+
+/**
+ * Returns typescript no-magical-numbers rule value;
+ * @returns {import('eslint').Linter.RuleEntry}
+ */
+const getUpdatedNoMagicalNumbersRule = () => {
+  /** @type {import('eslint').Linter.RuleEntry} */
+  const updatedRule = bestPractices.reduce(noMagicNumbersRuleReducer, 'off');
+
+  return updatedRule;
+};
+
+/** @type {import('eslint').Linter.Config[]} */
+const config = [
+  {
+    name: 'typescript-eslint/default-ts-rules',
+
+    /** @type {import('eslint').Linter.RulesRecord} */
+    rules: {
+      // Require that function overload signatures be consecutive.
+      // https://typescript-eslint.io/rules/adjacent-overload-signatures/
+      '@typescript-eslint/adjacent-overload-signatures': 'error',
+
+      // Enforce consistent usage of array type notation.
+      // https://typescript-eslint.io/rules/array-type/
+      '@typescript-eslint/array-type': [
+        'error',
+        {
+          'default': 'generic',
+          readonly: 'generic',
+        },
+      ],
+
+      // Disallow `@ts-<directive>` comments or require descriptions after directives.
+      // https://typescript-eslint.io/rules/ban-ts-comment/
+      '@typescript-eslint/ban-ts-comment': 'error',
+
+      // Disallow `// tslint:<rule-flag>` comments.
+      // https://typescript-eslint.io/rules/ban-tslint-comment/
+      '@typescript-eslint/ban-tslint-comment': 'error',
+
+      // Enforce that literals on classes are exposed in a consistent style.
+      // https://typescript-eslint.io/rules/class-literal-property-style/
+      '@typescript-eslint/class-literal-property-style': ['error', 'fields'],
+
+      // Enforce that class methods utilize `this`.
+      // https://typescript-eslint.io/rules/class-methods-use-this/
+      '@typescript-eslint/class-methods-use-this': 'error',
+
+      // Enforce specifying generic type arguments on type annotation or constructor name of a constructor call.
+      // https://typescript-eslint.io/rules/consistent-generic-constructors/
+      '@typescript-eslint/consistent-generic-constructors': ['error', 'constructor'],
+
+      // Enforce consistent usage of index signature or `Record` type for indexed object types.
+      // https://typescript-eslint.io/rules/consistent-indexed-object-style/
+      '@typescript-eslint/consistent-indexed-object-style': ['error', 'record'],
+
+      // Require `return` statements to either always or never specify values.
+      // https://typescript-eslint.io/rules/consistent-return/
+      '@typescript-eslint/consistent-return': 'error',
+
+      // Enforce consistent usage of type assertions.
+      // https://typescript-eslint.io/rules/consistent-type-assertions/
+      '@typescript-eslint/consistent-type-assertions': 'error',
+
+      // Enforce type definitions to consistently use either `interface` or `type`.
+      // https://typescript-eslint.io/rules/consistent-type-definitions/
+      '@typescript-eslint/consistent-type-definitions': 'off',
+
+      // Enforce consistent usage of type exports.
+      // https://typescript-eslint.io/rules/consistent-type-exports/
+      '@typescript-eslint/consistent-type-exports': 'error',
+
+      // Enforce consistent usage of type imports.
+      // https://typescript-eslint.io/rules/consistent-type-imports/
+      '@typescript-eslint/consistent-type-imports': ['error', {
+        disallowTypeAnnotations: true,
+        fixStyle: 'separate-type-imports',
+        prefer: 'type-imports',
+      }],
+
+      // Enforce default parameters to be last.
+      // https://typescript-eslint.io/rules/default-param-last/
+      '@typescript-eslint/default-param-last': 'error',
+
+      // Enforce dot notation whenever possible.
+      // https://typescript-eslint.io/rules/dot-notation/
+      '@typescript-eslint/dot-notation': [
+        'error',
+        {
+          allowIndexSignaturePropertyAccess: false,
+          allowPrivateClassPropertyAccess: false,
+          allowProtectedClassPropertyAccess: false,
+        },
+      ],
+
+      // Require explicit return types on functions and class methods.
+      // https://typescript-eslint.io/rules/explicit-function-return-type/
+      '@typescript-eslint/explicit-function-return-type': 'error',
+
+      // Require explicit accessibility modifiers on class properties and methods.
+      // https://typescript-eslint.io/rules/explicit-member-accessibility/
+      '@typescript-eslint/explicit-member-accessibility': 'error',
+
+      // Require explicit return and argument types on exported functions' and classes' public class methods.
+      // https://typescript-eslint.io/rules/explicit-module-boundary-types/
+      '@typescript-eslint/explicit-module-boundary-types': 'error',
+
+      // Require or disallow initialization in variable declarations.
+      // https://typescript-eslint.io/rules/init-declarations/
+      '@typescript-eslint/init-declarations': 'off',
+
+      // Enforce a maximum number of parameters in function definitions.
+      // https://typescript-eslint.io/rules/max-params/
+      '@typescript-eslint/max-params': 'off',
+
+      // Require a consistent member declaration order.
+      // https://typescript-eslint.io/rules/member-ordering/
+      '@typescript-eslint/member-ordering': 'error',
+
+      // Enforce using a particular method signature syntax.
+      // https://typescript-eslint.io/rules/method-signature-style/
+      '@typescript-eslint/method-signature-style': ['error', 'property'],
+
+      // Enforce naming conventions for everything across a codebase.
+      // https://typescript-eslint.io/rules/naming-convention/
+      '@typescript-eslint/naming-convention': [
+        'error',
+        {
+          format: ['PascalCase'],
+          leadingUnderscore: 'forbid',
+          prefix: ['E'],
+          selector: 'enum',
+          trailingUnderscore: 'forbid',
+        },
+        {
+          format: ['UPPER_CASE'],
+          leadingUnderscore: 'forbid',
+          selector: 'enumMember',
+          trailingUnderscore: 'forbid',
+        },
+        {
+          format: ['PascalCase'],
+          leadingUnderscore: 'forbid',
+          prefix: ['I'],
+          selector: 'interface',
+          trailingUnderscore: 'forbid',
+        },
+        {
+          format: ['PascalCase'],
+          leadingUnderscore: 'forbid',
+          prefix: ['T'],
+          selector: 'typeAlias',
+          trailingUnderscore: 'forbid',
+        },
+        {
+          format: ['PascalCase'],
+          leadingUnderscore: 'forbid',
+          selector: 'typeParameter',
+          trailingUnderscore: 'forbid',
+        },
+        {
+          format: ['camelCase', 'PascalCase', 'UPPER_CASE'],
+          leadingUnderscore: 'forbid',
+          selector: 'variable',
+          trailingUnderscore: 'forbid',
+        },
+      ],
+
+      // Disallow generic `Array` constructors.
+      // https://typescript-eslint.io/rules/no-array-constructor/
+      '@typescript-eslint/no-array-constructor': 'error',
+
+      // Disallow non-null assertions using the `!` postfix operator in locations that may be confusing.
+      // https://typescript-eslint.io/rules/no-confusing-non-null-assertion/
+      '@typescript-eslint/no-confusing-non-null-assertion': 'error',
+
+      // Require expressions of type void to appear in statement position.
+      // https://typescript-eslint.io/rules/no-confusing-void-expression/
+      '@typescript-eslint/no-confusing-void-expression': 'error',
+
+      // Disallow usage of deprecated APIs.
+      // https://typescript-eslint.io/rules/no-deprecated/
+      '@typescript-eslint/no-deprecated': 'warn',
+
+      // Disallow duplicate class members.
+      // https://typescript-eslint.io/rules/no-dupe-class-members/
+      '@typescript-eslint/no-dupe-class-members': 'error',
+
+      // Disallow duplicate enum member values.
+      // https://typescript-eslint.io/rules/no-duplicate-enum-values/
+      '@typescript-eslint/no-duplicate-enum-values': 'error',
+
+      // Disallow the use of the `delete` operator on computed key expressions.
+      // https://typescript-eslint.io/rules/no-dynamic-delete/
+      '@typescript-eslint/no-dynamic-delete': 'error',
+
+      // Disallow empty functions.
+      // https://typescript-eslint.io/rules/no-empty-function/
+      '@typescript-eslint/no-empty-function': [
+        'error',
+        {
+          allow: [],
+        },
+      ],
+
+      // Disallow usage of the {} type (empty interfaces or object type literals)
+      // https://typescript-eslint.io/rules/no-empty-object-type
+      '@typescript-eslint/no-empty-object-type': [
+        'error',
+        {
+          allowInterfaces: 'never',
+          allowObjectTypes: 'never',
+        },
+      ],
+
+      // Disallow the `any` type.
+      // https://typescript-eslint.io/rules/no-explicit-any/
+      '@typescript-eslint/no-explicit-any': 'error',
+
+      // Disallow extra non-null assertions (e.g., using !!)
+      // https://typescript-eslint.io/rules/no-extra-non-null-assertion
+      '@typescript-eslint/no-extra-non-null-assertion': 'error',
+
+      // Disallow classes that are empty or only contain static members
+      // https://typescript-eslint.io/rules/no-extraneous-class
+      '@typescript-eslint/no-extraneous-class': [
+        'error',
+        {
+          allowConstructorOnly: false,
+          allowEmpty: false,
+          allowStaticOnly: false,
+          allowWithDecorator: false,
+        },
+      ],
+
+      // Enforce using top-level type imports to avoid potential side effects
+      // https://typescript-eslint.io/rules/no-import-type-side-effects
+      '@typescript-eslint/no-import-type-side-effects': 'error',
+
+      // Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean
+      // https://typescript-eslint.io/rules/no-inferrable-types
+      '@typescript-eslint/no-inferrable-types': 'error',
+
+      // Disallow this keywords outside of classes or class-like objects
+      // https://typescript-eslint.io/rules/no-invalid-this
+      '@typescript-eslint/no-invalid-this': 'error',
+
+      // Disallow usage of void type outside of return types
+      // https://typescript-eslint.io/rules/no-invalid-void-type
+      '@typescript-eslint/no-invalid-void-type': [
+        'error',
+        {
+          allowAsThisParameter: false,
+          allowInGenericTypeArguments: true,
+        },
+      ],
+
+      // Disallow function declarations that contain unsafe references inside loop statements
+      // https://typescript-eslint.io/rules/no-loop-func
+      '@typescript-eslint/no-loop-func': 'error',
+
+      // Disallow magic numbers
+      // https://typescript-eslint.io/rules/no-magic-numbers
+      '@typescript-eslint/no-magic-numbers': getUpdatedNoMagicalNumbersRule(),
+
+      // Disallow the void operator except when used to discard a value.
+      // https://typescript-eslint.io/rules/no-meaningless-void-operator/
+      '@typescript-eslint/no-meaningless-void-operator': [
+        'error',
+        {
+          checkNever: false,
+        },
+      ],
+
+      // Enforce valid definition of `new` and `constructor`.
+      // https://typescript-eslint.io/rules/no-misused-new/
+      '@typescript-eslint/no-misused-new': 'error',
+
+      // Disallow using the spread operator when it might cause unexpected behavior.
+      // https://typescript-eslint.io/rules/no-misused-spread/
+      '@typescript-eslint/no-misused-spread': 'error',
+
+      // Disallow enums with mixed string and numeric members.
+      // https://typescript-eslint.io/rules/no-mixed-enums/
+      '@typescript-eslint/no-mixed-enums': 'error',
+
+      // Disallow TypeScript namespaces.
+      // https://typescript-eslint.io/rules/no-namespace/
+      '@typescript-eslint/no-namespace': [
+        'error',
+        {
+          allowDeclarations: false,
+          allowDefinitionFiles: true,
+        },
+      ],
+
+      // Disallow non-null assertions in the left operand of a nullish coalescing operator.
+      // https://typescript-eslint.io/rules/no-non-null-asserted-nullish-coalescing/
+      '@typescript-eslint/no-non-null-asserted-nullish-coalescing': 'error',
+
+      // Disallow non-null assertions after an optional chain expression.
+      // https://typescript-eslint.io/rules/no-non-null-asserted-optional-chain/
+      '@typescript-eslint/no-non-null-asserted-optional-chain': 'error',
+
+      // Disallow non-null assertions using the `!` postfix operator.
+      // https://typescript-eslint.io/rules/no-non-null-assertion/
+      '@typescript-eslint/no-non-null-assertion': 'error',
+
+      // Disallow variable redeclaration.
+      // https://eslint.org/docs/latest/rules/no-redeclare
+      '@typescript-eslint/no-redeclare': ['error', { builtinGlobals: true }],
+
+      // Disallow invocation of require().
+      // https://typescript-eslint.io/rules/no-require-imports
+      '@typescript-eslint/no-require-imports': 'error',
+
+      // Disallow specified modules when loaded by import.
+      // https://typescript-eslint.io/rules/no-restricted-imports
+      '@typescript-eslint/no-restricted-imports': 'error',
+
+      // Disallow specific types from being used.
+      // https://typescript-eslint.io/rules/no-restricted-types
+      '@typescript-eslint/no-restricted-types': 'error',
+
+      // Disallow variable declarations from shadowing variables declared in the outer scope.
+      // https://eslint.org/docs/latest/rules/no-shadow
+      '@typescript-eslint/no-shadow': ['error', { builtinGlobals: false }],
+
+      // Disallow aliasing this.
+      // https://typescript-eslint.io/rules/no-this-alias
+      '@typescript-eslint/no-this-alias': ['error', { allowedNames: [] }],
+
+      // Disallow unnecessary boolean literal comparisons.
+      // https://typescript-eslint.io/rules/no-unnecessary-boolean-literal-compare
+      '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error',
+
+      // Disallow conditionals where the type is always truthy or always falsy.
+      // https://typescript-eslint.io/rules/no-unnecessary-condition
+      '@typescript-eslint/no-unnecessary-condition': 'error',
+
+      // Disallow unnecessary assignment of constructor property parameter.
+      // https://typescript-eslint.io/rules/no-unnecessary-parameter-property-assignment/
+      '@typescript-eslint/no-unnecessary-parameter-property-assignment': 'error',
+
+      // Disallow unnecessary namespace qualifiers.
+      // https://typescript-eslint.io/rules/no-unnecessary-qualifier
+      '@typescript-eslint/no-unnecessary-qualifier': 'error',
+
+      // Disallow unnecessary template expressions.
+      // https://typescript-eslint.io/rules/no-unnecessary-template-expression/
+      '@typescript-eslint/no-unnecessary-template-expression': 'error',
+
+      // Disallow type arguments that are equal to the default.
+      // https://typescript-eslint.io/rules/no-unnecessary-type-arguments/
+      '@typescript-eslint/no-unnecessary-type-arguments': 'error',
+
+      // Disallow unnecessary constraints on generic types.
+      // https://typescript-eslint.io/rules/no-unnecessary-type-constraint/
+      '@typescript-eslint/no-unnecessary-type-constraint': 'error',
+
+      // Disallow conversion idioms when they do not change the type or value of the expression.
+      // https://typescript-eslint.io/rules/no-unnecessary-type-conversion/
+      '@typescript-eslint/no-unnecessary-type-conversion': 'error',
+
+      // Disallow type parameters that aren't used multiple times.
+      // https://typescript-eslint.io/rules/no-unnecessary-type-parameters/
+      '@typescript-eslint/no-unnecessary-type-parameters': 'error',
+
+      // Disallow unsafe declaration merging between classes and interfaces.
+      // https://typescript-eslint.io/rules/no-unsafe-declaration-merging/
+      '@typescript-eslint/no-unsafe-declaration-merging': 'error',
+
+      // Disallow using the unsafe built-in Function type.
+      // https://typescript-eslint.io/rules/no-unsafe-function-type/
+      '@typescript-eslint/no-unsafe-function-type': 'error',
+      // Disallow type assertions that narrow a type.
+      // https://typescript-eslint.io/rules/no-unsafe-type-assertion/
+      '@typescript-eslint/no-unsafe-type-assertion': 'error',
+
+      // Disallow unused expressions which have no effect on the state of the program.
+      // https://typescript-eslint.io/rules/no-unused-expressions/
+      '@typescript-eslint/no-unused-expressions': 'error',
+
+      // Disallow unused variables.
+      // https://typescript-eslint.io/rules/no-unused-vars/
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          args: 'after-used',
+          ignoreRestSiblings: true,
+          vars: 'all',
+        },
+      ],
+
+      // Disallow the use of variables before they are defined.
+      // https://typescript-eslint.io/rules/no-use-before-define/
+      '@typescript-eslint/no-use-before-define': [
+        'error',
+        {
+          classes: true,
+          enums: true,
+          functions: true,
+          ignoreTypeReferences: true,
+          typedefs: true,
+          variables: true,
+        },
+      ],
+
+      // Disallow unnecessary constructors.
+      // https://typescript-eslint.io/rules/no-useless-constructor/
+      '@typescript-eslint/no-useless-constructor': 'error',
+
+      // Disallow empty exports that don't change anything in a module file.
+      // https://typescript-eslint.io/rules/no-useless-empty-export/
+      '@typescript-eslint/no-useless-empty-export': 'error',
+
+      // Disallow using confusing built-in primitive class wrappers.
+      // https://typescript-eslint.io/rules/no-wrapper-object-types/
+      '@typescript-eslint/no-wrapper-object-types': 'error',
+
+      // Enforce using `!` non-null assertion instead of `as` when asserting non-nullability.
+      // https://typescript-eslint.io/rules/non-nullable-type-assertion-style/
+      '@typescript-eslint/non-nullable-type-assertion-style': 'error',
+
+      // Require or disallow parameter properties in class constructors.
+      // https://typescript-eslint.io/rules/parameter-properties/
+      '@typescript-eslint/parameter-properties': ['error', { prefer: 'class-property' }],
+
+      // Enforce the use of `as const` over literal type.
+      // https://typescript-eslint.io/rules/prefer-as-const/
+      '@typescript-eslint/prefer-as-const': 'error',
+
+      // Require destructuring from arrays and/or objects.
+      // https://typescript-eslint.io/rules/prefer-destructuring/
+      '@typescript-eslint/prefer-destructuring': 'error',
+
+      // Require each enum member value to be explicitly initialized.
+      // https://typescript-eslint.io/rules/prefer-enum-initializers/
+      '@typescript-eslint/prefer-enum-initializers': 'error',
+
+      // Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result.
+      // https://typescript-eslint.io/rules/prefer-find/
+      '@typescript-eslint/prefer-find': 'error',
+
+      // Enforce the use of `for-of` loop over the standard `for` loop where possible.
+      // https://typescript-eslint.io/rules/prefer-for-of/
+      '@typescript-eslint/prefer-for-of': 'error',
+      // Enforce using function types instead of interfaces with call signatures.
+      // https://typescript-eslint.io/rules/prefer-function-type/
+      '@typescript-eslint/prefer-function-type': 'error',
+
+      // Enforce using `includes` method over `indexOf` comparisons.
+      // https://typescript-eslint.io/rules/prefer-includes/
+      '@typescript-eslint/prefer-includes': 'error',
+
+      // Require all enum members to be literal values.
+      // https://typescript-eslint.io/rules/prefer-literal-enum-member/
+      '@typescript-eslint/prefer-literal-enum-member': [
+        'error',
+        {
+          allowBitwiseExpressions: true,
+        },
+      ],
+
+      // Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules.
+      // https://typescript-eslint.io/rules/prefer-namespace-keyword/
+      '@typescript-eslint/prefer-namespace-keyword': 'error',
+
+      // Enforce using the nullish coalescing operator (`??`) instead of logical assignments or chaining.
+      // https://typescript-eslint.io/rules/prefer-nullish-coalescing/
+      '@typescript-eslint/prefer-nullish-coalescing': 'error',
+
+      // Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects.
+      // https://typescript-eslint.io/rules/prefer-optional-chain/
+      '@typescript-eslint/prefer-optional-chain': 'error',
+
+      // Enforces that private members are marked as readonly if they're never modified outside of the constructor.
+      // https://typescript-eslint.io/rules/prefer-readonly/
+      '@typescript-eslint/prefer-readonly': 'error',
+
+      // Enforces that function parameters are typed as readonly to prevent unintended mutations.
+      // https://typescript-eslint.io/rules/prefer-readonly-parameter-types/
+      // Disabled due  to unsuported Typescript type aliases and bad destructuralization detected
+      '@typescript-eslint/prefer-readonly-parameter-types': 'off',
+
+      // Enforce using type parameter when calling `Array#reduce` instead of using a type assertion.
+      // https://typescript-eslint.io/rules/prefer-reduce-type-parameter/
+      '@typescript-eslint/prefer-reduce-type-parameter': 'error',
+
+      // Suggests using RegExp#exec over String#match when the global flag is not used.
+      // https://typescript-eslint.io/rules/prefer-regexp-exec/
+      '@typescript-eslint/prefer-regexp-exec': 'error',
+
+      // Enforces that class methods returning 'this' are correctly typed using 'this' instead of the class name.
+      // https://typescript-eslint.io/rules/prefer-return-this-type/
+      '@typescript-eslint/prefer-return-this-type': 'error',
+
+      // Suggests using String#startsWith and String#endsWith over other methods for readability.
+      // https://typescript-eslint.io/rules/prefer-string-starts-ends-with/
+      '@typescript-eslint/prefer-string-starts-ends-with': 'error',
+
+      // Requires that functions returning a Promise are marked as async.
+      // https://typescript-eslint.io/rules/promise-function-async/
+      '@typescript-eslint/promise-function-async': 'error',
+
+      // Ensures that getter and setter pairs have compatible types.
+      // https://typescript-eslint.io/rules/related-getter-setter-pairs/
+      '@typescript-eslint/related-getter-setter-pairs': 'error',
+
+      // Requires that Array#sort calls provide a compareFunction.
+      // https://typescript-eslint.io/rules/require-array-sort-compare/
+      '@typescript-eslint/require-array-sort-compare': 'error',
+
+      // Enforces consistent use of return await in functions.
+      // https://typescript-eslint.io/rules/return-await/
+      '@typescript-eslint/return-await': ['error', 'in-try-catch'],
+
+      // Restricts the types allowed in boolean expressions to avoid unintended behavior.
+      // https://typescript-eslint.io/rules/strict-boolean-expressions/
+      '@typescript-eslint/strict-boolean-expressions': [
+        'error',
+        {
+          allowAny: false,
+          allowNullableBoolean: true,
+          allowNullableEnum: true,
+          allowNullableNumber: true,
+          allowNullableObject: true,
+          allowNullableString: true,
+          allowNumber: false,
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+          allowString: true,
+        },
+      ],
+
+      // Ensures that switch statements are exhaustive.
+      // https://typescript-eslint.io/rules/switch-exhaustiveness-check/
+      '@typescript-eslint/switch-exhaustiveness-check': 'error',
+
+      // Disallows triple-slash reference directives.
+      // https://typescript-eslint.io/rules/triple-slash-reference/
+      '@typescript-eslint/triple-slash-reference': 'error',
+
+      // Enforces that function overloads be unified into a single signature when possible.
+      // https://typescript-eslint.io/rules/unified-signatures/
+      '@typescript-eslint/unified-signatures': 'error',
+
+      // Enforces the use of `unknown` instead of `any` in catch clause variables.
+      // https://typescript-eslint.io/rules/use-unknown-in-catch-callback-variable/
+      '@typescript-eslint/use-unknown-in-catch-callback-variable': 'error',
+    },
+  },
+];
+
+export default config;