@wistia/oxlint-config 0.2.0 → 0.3.0

package/rules/{typescript.jsonc → typescript.ts}

@@ -1,48 +1,48 @@
-{
-  "$schema": "../node_modules/oxlint/configuration_schema.json",
-  "plugins": ["typescript"],
-  "categories": {},
-  "rules": {
+import type { RuleFile } from '../types.ts';
+
+export const typescriptRules = {
+  plugins: ['typescript'],
+  rules: {
     // -- Disable base eslint rules superseded by typescript equivalents --
-    "eslint/class-methods-use-this": "off",
-    "eslint/default-param-last": "off",
-    "eslint/init-declarations": "off",
-    "eslint/max-params": "off",
-    "eslint/no-array-constructor": "off",
-    "eslint/no-dupe-class-members": "off",
-    "eslint/no-empty-function": "off",
-    "eslint/no-loop-func": "off",
-    "eslint/no-magic-numbers": "off",
-    "eslint/no-redeclare": "off",
-    "eslint/no-restricted-imports": "off",
-    "eslint/no-shadow": "off",
-    "eslint/no-throw-literal": "off",
-    "eslint/no-unused-expressions": "off",
-    "eslint/no-unused-private-class-members": "off",
-    "eslint/no-unused-vars": "off",
-    "eslint/no-use-before-define": "off",
-    "eslint/no-useless-constructor": "off",
-    "eslint/prefer-destructuring": "off",
-    "eslint/require-await": "off",
+    'eslint/class-methods-use-this': 'off',
+    'eslint/default-param-last': 'off',
+    'eslint/init-declarations': 'off',
+    'eslint/max-params': 'off',
+    'eslint/no-array-constructor': 'off',
+    'eslint/no-dupe-class-members': 'off',
+    'eslint/no-empty-function': 'off',
+    'eslint/no-loop-func': 'off',
+    'eslint/no-magic-numbers': 'off',
+    'eslint/no-redeclare': 'off',
+    'eslint/no-restricted-imports': 'off',
+    'eslint/no-shadow': 'off',
+    'eslint/no-throw-literal': 'off',
+    'eslint/no-unused-expressions': 'off',
+    'eslint/no-unused-private-class-members': 'off',
+    'eslint/no-unused-vars': 'off',
+    'eslint/no-use-before-define': 'off',
+    'eslint/no-useless-constructor': 'off',
+    'eslint/prefer-destructuring': 'off',
+    'eslint/require-await': 'off',
 
     // recommended to be disabled for TypeScript projects
     // https://github.com/typescript-eslint/typescript-eslint/blob/main/docs/linting/TROUBLESHOOTING.md#i-get-errors-from-the-no-undef-rule-about-global-variables-not-being-defined-even-though-there-are-no-typescript-errors
-    "eslint/no-undef": "off",
+    'eslint/no-undef': 'off',
 
     // Override base no-void to allow void as a statement (common in TS for fire-and-forget promises)
-    "eslint/no-void": ["error", { "allowAsStatement": true }],
+    'eslint/no-void': ['error', { allowAsStatement: true }],
 
     // Override base id-length to disable checking generic type parameters.
     // ESLint's id-length never sees TS type params (they're not in the ESLint AST),
     // but oxlint has native TS support so it checks them. Setting checkGeneric to
     // false restores parity with ESLint's behavior.
     // https://oxc.rs/docs/guide/usage/linter/rules/eslint/id-length.html
-    "eslint/id-length": [
-      "error",
+    'eslint/id-length': [
+      'error',
       {
-        "min": 2,
-        "exceptions": ["_", "i", "j", "x", "y"],
-        "checkGeneric": false,
+        min: 2,
+        exceptions: ['_', 'i', 'j', 'x', 'y'],
+        checkGeneric: false,
       },
     ],
 
@@ -50,408 +50,408 @@
 
     // Require that function overload signatures be consecutive
     // https://typescript-eslint.io/rules/adjacent-overload-signatures
-    "typescript/adjacent-overload-signatures": "error",
+    'typescript/adjacent-overload-signatures': 'error',
 
     // Require consistently using either T[] or Array<T> for arrays
     // https://typescript-eslint.io/rules/array-type
-    "typescript/array-type": "error",
+    'typescript/array-type': 'error',
 
     // Disallow awaiting a value that is not a Thenable
     // https://typescript-eslint.io/rules/await-thenable
-    "typescript/await-thenable": "error",
+    'typescript/await-thenable': 'error',
 
     // Disallow @ts-<directive> comments or require descriptions after directives
     // https://typescript-eslint.io/rules/ban-ts-comment
-    "typescript/ban-ts-comment": "error",
+    'typescript/ban-ts-comment': 'error',
 
     // Disallow // tslint:<rule-flag> comments
     // https://typescript-eslint.io/rules/ban-tslint-comment
-    "typescript/ban-tslint-comment": "error",
+    'typescript/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/class-literal-property-style": "error",
+    'typescript/class-literal-property-style': '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/consistent-generic-constructors": "error",
+    'typescript/consistent-generic-constructors': 'error',
 
     // Require or disallow the Record type
     // https://typescript-eslint.io/rules/consistent-indexed-object-style
-    "typescript/consistent-indexed-object-style": "error",
+    'typescript/consistent-indexed-object-style': 'error',
 
     // Enforce consistent usage of type assertions
     // https://typescript-eslint.io/rules/consistent-type-assertions
-    "typescript/consistent-type-assertions": "error",
+    'typescript/consistent-type-assertions': 'error',
 
     // Enforce type definitions to consistently use either interface or type
     // https://typescript-eslint.io/rules/consistent-type-definitions
     // decision: prefer type to interface for consistency
-    "typescript/consistent-type-definitions": ["error", "type"],
+    'typescript/consistent-type-definitions': ['error', 'type'],
 
     // Enforce consistent usage of type exports
     // https://typescript-eslint.io/rules/consistent-type-exports
-    "typescript/consistent-type-exports": "error",
+    'typescript/consistent-type-exports': 'error',
 
     // Enforce consistent usage of type imports
     // https://typescript-eslint.io/rules/consistent-type-imports
-    "typescript/consistent-type-imports": [
-      "error",
+    'typescript/consistent-type-imports': [
+      'error',
       {
-        "prefer": "type-imports",
-        "disallowTypeAnnotations": false,
-        "fixStyle": "separate-type-imports",
+        prefer: 'type-imports',
+        disallowTypeAnnotations: false,
+        fixStyle: 'separate-type-imports',
       },
     ],
 
     // Enforce dot notation whenever possible
     // https://typescript-eslint.io/rules/dot-notation
-    "typescript/dot-notation": "error",
+    'typescript/dot-notation': 'error',
 
     // Require explicit accessibility modifiers on class properties and methods
     // https://typescript-eslint.io/rules/explicit-module-boundary-types
-    "typescript/explicit-module-boundary-types": "error",
+    'typescript/explicit-module-boundary-types': 'error',
 
     // Disallow using the delete operator on array values
     // https://typescript-eslint.io/rules/no-array-delete
-    "typescript/no-array-delete": "error",
+    'typescript/no-array-delete': 'error',
 
     // Require .toString() to only be called on objects which provide useful information
     // https://typescript-eslint.io/rules/no-base-to-string
-    "typescript/no-base-to-string": "error",
+    'typescript/no-base-to-string': 'error',
 
     // Disallow non-null assertion in locations that may be confusing
     // https://typescript-eslint.io/rules/no-confusing-non-null-assertion
-    "typescript/no-confusing-non-null-assertion": "error",
+    'typescript/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/no-confusing-void-expression": ["error", { "ignoreArrowShorthand": true }],
+    'typescript/no-confusing-void-expression': ['error', { ignoreArrowShorthand: true }],
 
     // Disallow using code marked as @deprecated
     // https://typescript-eslint.io/rules/no-deprecated
-    "typescript/no-deprecated": "error",
+    'typescript/no-deprecated': 'error',
 
     // Disallow duplicate enum member values
     // https://typescript-eslint.io/rules/no-duplicate-enum-values
-    "typescript/no-duplicate-enum-values": "error",
+    'typescript/no-duplicate-enum-values': 'error',
 
     // Disallow duplicate constituents of union or intersection types
     // https://typescript-eslint.io/rules/no-duplicate-type-constituents
-    "typescript/no-duplicate-type-constituents": "error",
+    'typescript/no-duplicate-type-constituents': 'error',
 
     // Disallow using the delete operator on computed key expressions
     // https://typescript-eslint.io/rules/no-dynamic-delete
-    "typescript/no-dynamic-delete": "error",
+    'typescript/no-dynamic-delete': 'error',
 
     // Disallow accidentally using the "empty object" type
     // https://typescript-eslint.io/rules/no-empty-object-type
-    "typescript/no-empty-object-type": "error",
+    'typescript/no-empty-object-type': 'error',
 
     // Disallow the any type
     // https://typescript-eslint.io/rules/no-explicit-any
-    "typescript/no-explicit-any": "error",
+    'typescript/no-explicit-any': 'error',
 
     // Disallow extra non-null assertions
     // https://typescript-eslint.io/rules/no-extra-non-null-assertion
-    "typescript/no-extra-non-null-assertion": "error",
+    'typescript/no-extra-non-null-assertion': 'error',
 
     // Disallow classes used as namespaces
     // https://typescript-eslint.io/rules/no-extraneous-class
-    "typescript/no-extraneous-class": "error",
+    'typescript/no-extraneous-class': 'error',
 
     // Require Promise-like statements to be handled appropriately
     // https://typescript-eslint.io/rules/no-floating-promises
-    "typescript/no-floating-promises": "error",
+    'typescript/no-floating-promises': 'error',
 
     // Disallow iterating over an array with a for-in loop
     // https://typescript-eslint.io/rules/no-for-in-array
-    "typescript/no-for-in-array": "error",
+    'typescript/no-for-in-array': 'error',
 
     // Disallow the use of eval()-like methods
     // https://typescript-eslint.io/rules/no-implied-eval
-    "typescript/no-implied-eval": "error",
+    'typescript/no-implied-eval': 'error',
 
     // Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers
     // https://typescript-eslint.io/rules/no-import-type-side-effects
-    "typescript/no-import-type-side-effects": "error",
+    'typescript/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/no-inferrable-types": "error",
+    'typescript/no-inferrable-types': 'error',
 
     // Disallow void type outside of generic or return types
     // https://typescript-eslint.io/rules/no-invalid-void-type
-    "typescript/no-invalid-void-type": "error",
+    'typescript/no-invalid-void-type': 'error',
 
     // Disallow the void operator except when used to discard a value
     // https://typescript-eslint.io/rules/no-meaningless-void-operator
-    "typescript/no-meaningless-void-operator": "error",
+    'typescript/no-meaningless-void-operator': 'error',
 
     // Enforce valid definition of new and constructor
     // https://typescript-eslint.io/rules/no-misused-new
-    "typescript/no-misused-new": "error",
+    'typescript/no-misused-new': 'error',
 
     // Disallow Promises in places not designed to handle them
     // https://typescript-eslint.io/rules/no-misused-promises
-    "typescript/no-misused-promises": "error",
+    'typescript/no-misused-promises': 'error',
 
     // Disallow using the spread operator when it might cause unexpected behavior
     // https://typescript-eslint.io/rules/no-misused-spread
-    "typescript/no-misused-spread": "error",
+    'typescript/no-misused-spread': 'error',
 
     // Disallow enums from having both number and string members
     // https://typescript-eslint.io/rules/no-mixed-enums
-    "typescript/no-mixed-enums": "error",
+    'typescript/no-mixed-enums': 'error',
 
     // Disallow TypeScript namespaces
     // https://typescript-eslint.io/rules/no-namespace
-    "typescript/no-namespace": "error",
+    'typescript/no-namespace': 'error',
 
     // 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/no-non-null-asserted-nullish-coalescing": "error",
+    'typescript/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/no-non-null-asserted-optional-chain": "error",
+    'typescript/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/no-non-null-assertion": "error",
+    'typescript/no-non-null-assertion': 'error',
 
     // Disallow members of unions and intersections that do nothing or override type information
     // https://typescript-eslint.io/rules/no-redundant-type-constituents
-    "typescript/no-redundant-type-constituents": "error",
+    'typescript/no-redundant-type-constituents': 'error',
 
     // Disallow invocation of require()
     // https://typescript-eslint.io/rules/no-require-imports
-    "typescript/no-require-imports": "error",
+    'typescript/no-require-imports': 'error',
 
     // Disallow certain types
     // https://typescript-eslint.io/rules/no-restricted-types
-    "typescript/no-restricted-types": "error",
+    'typescript/no-restricted-types': 'error',
 
     // Disallow aliasing this
     // https://typescript-eslint.io/rules/no-this-alias
-    "typescript/no-this-alias": "error",
+    'typescript/no-this-alias': 'error',
 
     // Disallow unnecessary equality comparisons against boolean literals
     // https://typescript-eslint.io/rules/no-unnecessary-boolean-literal-compare
-    "typescript/no-unnecessary-boolean-literal-compare": "error",
+    'typescript/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/no-unnecessary-condition": "error",
+    'typescript/no-unnecessary-condition': 'error',
 
     // Disallow unnecessary assignment of constructor property parameter
     // https://typescript-eslint.io/rules/no-unnecessary-parameter-property-assignment
-    "typescript/no-unnecessary-parameter-property-assignment": "error",
+    'typescript/no-unnecessary-parameter-property-assignment': 'error',
 
     // Disallow unnecessary namespace qualifiers
     // https://typescript-eslint.io/rules/no-unnecessary-qualifier
-    "typescript/no-unnecessary-qualifier": "error",
+    'typescript/no-unnecessary-qualifier': 'error',
 
     // Disallow unnecessary template expressions
     // https://typescript-eslint.io/rules/no-unnecessary-template-expression
-    "typescript/no-unnecessary-template-expression": "error",
+    'typescript/no-unnecessary-template-expression': 'error',
 
     // Disallow type arguments that are equal to the default
     // https://typescript-eslint.io/rules/no-unnecessary-type-arguments
-    "typescript/no-unnecessary-type-arguments": "error",
+    'typescript/no-unnecessary-type-arguments': 'error',
 
     // Disallow type assertions that do not change the type of an expression
     // https://typescript-eslint.io/rules/no-unnecessary-type-assertion
-    "typescript/no-unnecessary-type-assertion": "error",
+    'typescript/no-unnecessary-type-assertion': 'error',
 
     // Disallow unnecessary constraints on generic types
     // https://typescript-eslint.io/rules/no-unnecessary-type-constraint
-    "typescript/no-unnecessary-type-constraint": "error",
+    'typescript/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/no-unnecessary-type-conversion": "error",
+    'typescript/no-unnecessary-type-conversion': 'error',
 
     // Disallow type parameters that only appear once
     // https://typescript-eslint.io/rules/no-unnecessary-type-parameters
-    "typescript/no-unnecessary-type-parameters": "error",
+    'typescript/no-unnecessary-type-parameters': 'error',
 
     // Disallow calling a function with a value with type any
     // https://typescript-eslint.io/rules/no-unsafe-argument
-    "typescript/no-unsafe-argument": "error",
+    'typescript/no-unsafe-argument': 'error',
 
     // Disallow assigning a value with type any to variables and properties
     // https://typescript-eslint.io/rules/no-unsafe-assignment
-    "typescript/no-unsafe-assignment": "error",
+    'typescript/no-unsafe-assignment': 'error',
 
     // Disallow calling a value with type any
     // https://typescript-eslint.io/rules/no-unsafe-call
-    "typescript/no-unsafe-call": "error",
+    'typescript/no-unsafe-call': 'error',
 
     // Disallow unsafe declaration merging
     // https://typescript-eslint.io/rules/no-unsafe-declaration-merging
-    "typescript/no-unsafe-declaration-merging": "error",
+    'typescript/no-unsafe-declaration-merging': 'error',
 
     // Disallow comparing an enum value with a non-enum value
     // https://typescript-eslint.io/rules/no-unsafe-enum-comparison
-    "typescript/no-unsafe-enum-comparison": "error",
+    'typescript/no-unsafe-enum-comparison': 'error',
 
     // Disallow using the unsafe built-in Function type
     // https://typescript-eslint.io/rules/no-unsafe-function-type
-    "typescript/no-unsafe-function-type": "error",
+    'typescript/no-unsafe-function-type': 'error',
 
     // Disallow member access on a value with type any
     // https://typescript-eslint.io/rules/no-unsafe-member-access
-    "typescript/no-unsafe-member-access": "error",
+    'typescript/no-unsafe-member-access': 'error',
 
     // Disallow returning a value with type any from a function
     // https://typescript-eslint.io/rules/no-unsafe-return
-    "typescript/no-unsafe-return": "error",
+    'typescript/no-unsafe-return': 'error',
 
     // Disallow type assertions that narrow a type
     // https://typescript-eslint.io/rules/no-unsafe-type-assertion
-    "typescript/no-unsafe-type-assertion": "error",
+    'typescript/no-unsafe-type-assertion': 'error',
 
     // Require unary negation to take a number
     // https://typescript-eslint.io/rules/no-unsafe-unary-minus
-    "typescript/no-unsafe-unary-minus": "error",
+    'typescript/no-unsafe-unary-minus': 'error',
 
     // Disallow empty exports that don't change anything in a module file
     // https://typescript-eslint.io/rules/no-useless-empty-export
-    "typescript/no-useless-empty-export": "error",
+    'typescript/no-useless-empty-export': 'error',
 
     // Disallow using confusing built-in primitive class wrappers
     // https://typescript-eslint.io/rules/no-wrapper-object-types
-    "typescript/no-wrapper-object-types": "error",
+    'typescript/no-wrapper-object-types': 'error',
 
     // Enforce non-null assertions over explicit type casts
     // https://typescript-eslint.io/rules/non-nullable-type-assertion-style
     // decision: disabled because it conflicts with `no-non-null-assertion` — this rule's autofix
     // rewrites `value as T` to `value!`, which `no-non-null-assertion` then rejects
-    "typescript/non-nullable-type-assertion-style": "off",
+    'typescript/non-nullable-type-assertion-style': 'off',
 
     // Disallow throwing non-Error values as exceptions
     // https://typescript-eslint.io/rules/only-throw-error
-    "typescript/only-throw-error": "error",
+    'typescript/only-throw-error': 'error',
 
     // Require or disallow parameter properties in class constructors
     // https://typescript-eslint.io/rules/parameter-properties
-    "typescript/parameter-properties": "error",
+    'typescript/parameter-properties': 'error',
 
     // Enforce the use of as const over literal type
     // https://typescript-eslint.io/rules/prefer-as-const
-    "typescript/prefer-as-const": "error",
+    'typescript/prefer-as-const': 'error',
 
     // Require each enum member value to be explicitly initialized
     // https://typescript-eslint.io/rules/prefer-enum-initializers
-    "typescript/prefer-enum-initializers": "error",
+    'typescript/prefer-enum-initializers': 'error',
 
     // Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0]
     // https://typescript-eslint.io/rules/prefer-find
-    "typescript/prefer-find": "error",
+    'typescript/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/prefer-for-of": "error",
+    'typescript/prefer-for-of': 'error',
 
     // Enforce using function types instead of interfaces with call signatures
     // https://typescript-eslint.io/rules/prefer-function-type
-    "typescript/prefer-function-type": "error",
+    'typescript/prefer-function-type': 'error',
 
     // Enforce includes method over indexOf method
     // https://typescript-eslint.io/rules/prefer-includes
-    "typescript/prefer-includes": "error",
+    'typescript/prefer-includes': 'error',
 
     // Require all enum members to be literal values
     // https://typescript-eslint.io/rules/prefer-literal-enum-member
-    "typescript/prefer-literal-enum-member": "error",
+    'typescript/prefer-literal-enum-member': 'error',
 
     // Require using namespace keyword over module keyword to declare custom TypeScript modules
     // https://typescript-eslint.io/rules/prefer-namespace-keyword
-    "typescript/prefer-namespace-keyword": "error",
+    'typescript/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/prefer-nullish-coalescing": "error",
+    'typescript/prefer-nullish-coalescing': 'error',
 
     // Enforce using concise optional chain expressions
     // https://typescript-eslint.io/rules/prefer-optional-chain
-    "typescript/prefer-optional-chain": "error",
+    'typescript/prefer-optional-chain': 'error',
 
     // Require using Error objects as Promise rejection reasons
     // https://typescript-eslint.io/rules/prefer-promise-reject-errors
-    "typescript/prefer-promise-reject-errors": "error",
+    'typescript/prefer-promise-reject-errors': 'error',
 
     // Require private members to be marked as readonly if they're never modified outside of the constructor
     // https://typescript-eslint.io/rules/prefer-readonly
-    "typescript/prefer-readonly": "error",
+    'typescript/prefer-readonly': 'error',
 
     // Enforce using type parameter when calling Array#reduce instead of casting
     // https://typescript-eslint.io/rules/prefer-reduce-type-parameter
-    "typescript/prefer-reduce-type-parameter": "error",
+    'typescript/prefer-reduce-type-parameter': 'error',
 
     // Enforce RegExp#exec over String#match if no global flag is provided
     // https://typescript-eslint.io/rules/prefer-regexp-exec
-    "typescript/prefer-regexp-exec": "error",
+    'typescript/prefer-regexp-exec': 'error',
 
     // Enforce that this is used when only this type is returned
     // https://typescript-eslint.io/rules/prefer-return-this-type
-    "typescript/prefer-return-this-type": "error",
+    'typescript/prefer-return-this-type': 'error',
 
     // Enforce using String#startsWith and String#endsWith over other equivalent methods
     // https://typescript-eslint.io/rules/prefer-string-starts-ends-with
-    "typescript/prefer-string-starts-ends-with": "error",
+    'typescript/prefer-string-starts-ends-with': 'error',
 
     // Require any function or method that returns a Promise to be marked async
     // https://typescript-eslint.io/rules/promise-function-async
-    "typescript/promise-function-async": "error",
+    'typescript/promise-function-async': 'error',
 
     // Enforce that get() types should be assignable to their equivalent set() type
     // https://typescript-eslint.io/rules/related-getter-setter-pairs
-    "typescript/related-getter-setter-pairs": "error",
+    'typescript/related-getter-setter-pairs': 'error',
 
     // Require Array#sort and Array#toSorted calls to always provide a compareFunction
     // https://typescript-eslint.io/rules/require-array-sort-compare
-    "typescript/require-array-sort-compare": "error",
+    'typescript/require-array-sort-compare': 'error',
 
     // Disallow async functions which do not return promises and have no await expression
     // https://typescript-eslint.io/rules/require-await
-    "typescript/require-await": "error",
+    'typescript/require-await': 'error',
 
     // Require both operands of addition to be the same type
     // https://typescript-eslint.io/rules/restrict-plus-operands
-    "typescript/restrict-plus-operands": "error",
+    'typescript/restrict-plus-operands': 'error',
 
     // Enforce template literal expressions to be of string type
     // https://typescript-eslint.io/rules/restrict-template-expressions
-    "typescript/restrict-template-expressions": "error",
+    'typescript/restrict-template-expressions': 'error',
 
     // Enforce consistent awaiting of returned promises
     // https://typescript-eslint.io/rules/return-await
-    "typescript/return-await": "error",
+    'typescript/return-await': 'error',
 
     // Disallow certain types in boolean expressions
     // https://typescript-eslint.io/rules/strict-boolean-expressions
-    "typescript/strict-boolean-expressions": ["error", { "allowNullableBoolean": true }],
+    'typescript/strict-boolean-expressions': ['error', { allowNullableBoolean: true }],
 
     // Require switch-case statements to be exhaustive
     // https://typescript-eslint.io/rules/switch-exhaustiveness-check
-    "typescript/switch-exhaustiveness-check": "error",
+    'typescript/switch-exhaustiveness-check': 'error',
 
     // Disallow certain triple slash directives in favor of ES6-style import declarations
     // https://typescript-eslint.io/rules/triple-slash-reference
-    "typescript/triple-slash-reference": "error",
+    'typescript/triple-slash-reference': 'error',
 
     // Enforce unbound methods are called with their expected scope
     // https://typescript-eslint.io/rules/unbound-method
-    "typescript/unbound-method": "error",
+    'typescript/unbound-method': 'error',
 
     // Disallow two overloads that could be unified into one
     // https://typescript-eslint.io/rules/unified-signatures
-    "typescript/unified-signatures": "error",
+    'typescript/unified-signatures': 'error',
 
     // Enforce typing arguments in .catch() callbacks as unknown
     // https://typescript-eslint.io/rules/use-unknown-in-catch-callback-variable
-    "typescript/use-unknown-in-catch-callback-variable": "error",
+    'typescript/use-unknown-in-catch-callback-variable': 'error',
   },
-}
+} satisfies RuleFile;