When emitting with a timeout (added in version 4.4.0), the "err"
argument was not properly typed and would require to split the client
and server typings. It will now be automatically inferred as an Error
object.

Workaround for previous versions:

```ts
type WithTimeoutAck<isEmitter extends boolean, args extends any[]> = isEmitter extends true ? [Error, ...args] : args;

interface ClientToServerEvents<isEmitter extends boolean = false> {
    withAck: (data: { argName: boolean }, callback: (...args: WithTimeoutAck<isEmitter, [string]>) => void) => void;
}

interface ServerToClientEvents<isEmitter extends boolean = false> {

}

const io = new Server<ClientToServerEvents, ServerToClientEvents<true>>(3000);

io.on("connection", (socket) => {
    socket.on("withAck", (val, cb) => {
        cb("123");
    });
});

const socket: Socket<ServerToClientEvents, ClientToServerEvents<true>> = ioc("http://localhost:3000");

socket.timeout(100).emit("withAck", { argName: true }, (err, val) => {
  // ...
});
```

Related: #1555

This follows [1], in order to keep the label of each argument.

[1]: 33e4172

Related:

- #1570 (comment)
- microsoft/TypeScript#39941
- microsoft/TypeScript#48049

Connection state recovery allows a client to reconnect after a
temporary disconnection and restore its state:

- id
- rooms
- data
- missed packets

See also: socketio/socket.io@54d5ee0

This commit adds some syntactic sugar around acknowledgements:

```js
// without timeout
const response = await socket.emitWithAck("hello", "world");

// with a specific timeout
try {
  const response = await socket.timeout(1000).emitWithAck("hello", "world");
} catch (err) {
  // the server did not acknowledge the event in the given delay
}
```

Note: enviroments that do not support Promises ([1]) will need to add a
polyfill in order to use this feature

See also: socketio/socket.io@184f3cf

[1]: https://caniuse.com/promises

Following b4e20c5

Syntax:

```js
const socket = io({
  retries: 3,
  ackTimeout: 10000
});

// "my-event" will be sent up to 4 times (1 + 3), until the server sends an acknowledgement
socket.emit("my-event", (err) => {});
```

Notes:

- the order of the packets is guaranteed, as we send packets one by one
- the same packet id is reused for consecutive retries, in order to
allow deduplication on the server side

Related: #1460

Diff: socketio/engine.io-client@6.2.3...6.3.0
Release notes: https://github.com/socketio/engine.io-client/releases/tag/6.3.0

Following 655dce9

Diff: socketio/engine.io-client@6.3.0...6.3.1
Release notes: https://github.com/socketio/engine.io-client/releases/tag/6.3.1

Related:

- #1561
- b862924
- socketio/engine.io-client@37d7a0a

The minor bump is due to changes on the server side, but we'll keep the
versions in sync.

Diff: socketio/engine.io-client@6.3.1...6.4.0
Release notes: https://github.com/socketio/engine.io-client/releases/tag/6.4.0

Diff: 4.5.4...4.6.0