This rule ensures
```js
const obj = {
  foo: 'bar',
  baz,
}
```

Instead of allowing
```js
const obj = {
  foo: 'bar',
  baz: baz,
}
```

This rule ensures:
```js
const foo = { bar: 'baz' };
```

Instead of allowing:
```js
const foo = { bar:'baz' };
```

Ensures a space exists before the start of a block that is not on a new line.
[Documentation](https://typescript-eslint.io/rules/space-before-blocks/)

This rule ensures:
```js
if (foo) {
  //
}
```

Instead of allowing:
```js
if (foo){
  //
}
```

Ensures a space exists before and after the `=>` in an arrow function.
[Documentation](https://eslint.org/docs/latest/rules/arrow-spacing)

This rule ensures:
```js
() => {
  //
};
```

Instead of allowing:
```js
()=>{
  //
};
```

Ensures parenthesis around arrow function parameters are only used when required.
[Documentation](https://eslint.org/docs/latest/rules/arrow-parens)

This rule ensures:
```js
foo => {
  //
};

(foo, bar) => {
  //
};
```

Instead of allowing:
```js
(foo) => {
  //
};

(foo, bar) => {
  //
};
```

Ensures 1tbs (one true brace style), where braces must be on the same line as the keywords they're associated with.
[Documentation](https://typescript-eslint.io/rules/brace-style/)

This rule ensures:
```js
if (foo) {
  //
} else {
  //
}

try {
  //
} catch(error) {
  //
}
```

Instead of allowing:
```js
if (foo)
{
  //
}
else {
  //
}

try
{
  //
}
catch(error)
{
  //
}
```

Ensures semicolon delimiters between members of interface and type literals.
[Documentation](https://typescript-eslint.io/rules/member-delimiter-style)

This rule ensures:
```js
interface Foo {
    name: string;
    greet(): string;
}

type Bar = { name: string }
type FooBar = { name: string; greet(): string }
```

Instead of allowing:
```js
interface Foo {
    name: string
    greet(): string
}

interface Foo {
    name: string,
    greet(): string,
}

interface Foo {
    name: string;
    greet(): string
}

type FooBar = { name: string, greet(): string }
```

Ensures array brackets are either both on new lines or are both on the same line.
[Documentation](https://eslint.org/docs/latest/rules/array-bracket-newline)

This rule ensures:
```js
const foo = [];

const foo = [ 1, 2, 3 ];

const foo = [
  1,
  2,
  3,
];

const foo = [{
  bar: baz
}];

const foo = [
  { bar: baz }
];
```

Instead of allowing:
```js
const foo = [
];

const foo = [
  1, 2, 3 ];

const foo = [
  1,
  2,
  3];

const foo = [{
    bar: baz
  }
];

const foo = [
  { bar: baz }];
```

Ensures object braces are either both on new lines or are both on the same line.
[Documentation](https://eslint.org/docs/latest/rules/object-curly-newline)

This rule ensures:
```js
const foo = {};

const foo = { bar: baz };

const foo = {
  bar: baz,
};

const { bar } = obj;

const {
  bar
} = obj;
```

Instead of allowing:
```js
const foo = {
};

const foo = { bar: baz
};

const foo = {
  bar: baz};

const { bar
} = obj;
```

Ensures there is not a new line before or after the body of a block.
[Documentation](https://eslint.org/docs/latest/rules/padded-blocks)

This rule ensures:
```js
if (foo) {
  //
}
```

Instead of allowing:
```js
if (foo) {

  //

}

if (foo) {

  //
}

if (foo) {
  //

}
```

Ensures all exports are declared at the bottom of the file.
[Documentation](https://github.com/import-js/eslint-plugin-import/blob/5680a1f8d41cd19f9c60d999a6fadf10994a0a64/docs/rules/exports-last.md)

This rule ensures:
```js
const str = 'foo';
const bool = true;

export {
  str,
  bool,
};
```

```js
const str = 'foo';

export const bool = true;
```

Instead of allowing:
```js
export const bool = true;

const str = 'foo';
```

Ensures consistent indentation.
[Documentation](https://typescript-eslint.io/rules/indent)

!! This has [known issues](typescript-eslint/typescript-eslint#1824), revert to ESLint's version if necessary.

This rule ensures:
```js
function foo() {
  if (bar) {
    console.log('baz');
  } else {
    console.log('qux');
  }
}

switch(a){
  case "a":
    break;
  case "b":
    break;
}
```

Instead of allowing:
```js
function foo() {
 if (bar) {
console.log('baz');
} else {
     console.log('qux');
 }
}

switch(a){
case "a":
    break;
case "b":
    break;
}
```

We're already using `@typescript-eslint/no-unused-vars`, the
[docs](https://typescript-eslint.io/rules/no-unused-vars) state to
explicitly disable `no-unused-vars` to avoid conflicts.

Ensures semicolons are added after each statement, including TypeScript statements.
[Documentation](https://typescript-eslint.io/rules/semi)

This rule ensures:
```js
type ClientUser = Pick<User, 'id' | 'discord_user_id'>;

const foo = 'bar';

object.foo = function() {
    //
};

class Foo {
    bar = 1;
}
```

Instead of allowing:
```js
type ClientUser = Pick<User, 'id' | 'discord_user_id'>

const foo = 'bar'

object.foo = function() {
    //
}

class Foo {
    bar = 1
}
```

Ensures there is an empty line after directives.
[Documentation](https://eslint.org/docs/latest/rules/padding-line-between-statements)

This rule ensures:
```js
'use strict';

const foo = 'bar';
```

Instead of allowing:
```js
'use strict';
const foo = 'bar';
```

Ensures spacing around keywords such as `if`, `else`, `function`, `try`, `catch`, etc.
[Documentation](https://typescript-eslint.io/rules/keyword-spacing)

This rule ensures:
```js
if (foo) {
    //...
} else if (bar) {
    //...
} else {
    //...
}
```

Instead of allowing:
```js
if (foo) {
    //...
}else if (bar) {
    //...
}else {
    //...
}
```

Ensures spacing around operators such as `+`, `-`, `?`, `:`, `=`, etc.
[Documentation](https://typescript-eslint.io/rules/space-infix-ops)

This rule ensures:
```js
a + b

a       + b

a ? b : c

// `object-curly-spacing` would ensure spacing inside `{}`
var {a = 0} = bar;

// `key-spacing` would ensure a space after `:`
const a = {b:1};

function foo(a = 0) {}
```

Instead of allowing:
```js
a+b

a+ b

a +b

a?b:c

var {a=0}=bar;

const a={b:1};

function foo(a=0) { }
```