How to use the socketcluster-client.create function in socketcluster-client

public async init() {
        // launching a "mock socket server" so that we can mock a peer
        this.serverProcess = fork(__dirname + "/index.js");

        await delay(2000);

        // client socket so we can send mocking instructions to our mock server
        this.clientSocket = socketCluster.create({
            port: 4009,
            hostname: "127.0.0.1",
        });
    }

? peerConfig.connectTimeout
						? peerConfig.connectTimeout
						: DEFAULT_CONNECT_TIMEOUT
					: DEFAULT_CONNECT_TIMEOUT,
				ackTimeout: peerConfig
					? peerConfig.connectTimeout
						? peerConfig.connectTimeout
						: DEFAULT_CONNECT_TIMEOUT
					: DEFAULT_ACK_TIMEOUT,
				multiplex: false,
				autoConnect: false,
				autoReconnect: false,
				pingTimeoutDisabled: true,
			};

			const outboundSocket = socketClusterClient.create(clientOptions);
			// Attaching handlers for various events that could be used future for logging or any other application
			outboundSocket.emit(
				REMOTE_EVENT_RPC_REQUEST,
				{
					type: '/RPCRequest',
					procedure: requestPacket.procedure,
				},
				(err: Error | undefined, responseData: unknown) => {
					if (err) {
						reject(err);

						return;
					}
					if (responseData) {
						const responsePacket = responseData as P2PResponsePacket;
						resolve({

private create(peer: P2P.IPeer): SCClientSocket {
        const connection = create({
            port: peer.port,
            hostname: peer.ip,
            perMessageDeflate: true,
        });

        const socket = (connection as any).transport.socket;

        socket.on("ping", () => this.terminate(peer));
        socket.on("pong", () => this.terminate(peer));
        socket.on("message", data => {
            if (data === "#1") {
                // this is to establish some rate limit on #1 messages
                // a simple rate limit of 1 per second doesnt seem to be enough, so decided to give some margin
                // and allow up to 10 per second which should be more than enough
                const timeNow: number = new Date().getTime();
                socket._last10Pings = socket._last10Pings || [];

this.hosts = hosts.map(host => {
            host.socket = socketCluster.create({
                ...host,
                autoReconnectOptions: {
                    initialDelay: 1000,
                    maxDelay: 1000,
                },
            });

            host.socket.on("error", err => {
                if (err.message !== "Socket hung up") {
                    this.logger.error(err.message);
                }
            });

            return host;
        });

const clientOptions: ClientOptionsUpdated = {
			hostname: this._ipAddress,
			port: this._wsPort,
			query: querystring.stringify({
				...legacyNodeInfo,
				options: JSON.stringify(legacyNodeInfo),
			}),
			connectTimeout,
			ackTimeout,
			multiplex: false,
			autoConnect: false,
			autoReconnect: false,
			pingTimeoutDisabled: true,
		};

		const outboundSocket = socketClusterClient.create(clientOptions);

		this._bindHandlersToOutboundSocket(outboundSocket);

		return outboundSocket;
	}

query: querystring.stringify({
				...legacyNodeInfo,
				options:
					legacyNodeInfo && legacyNodeInfo.options
						? JSON.stringify(legacyNodeInfo.options)
						: undefined,
			}),
			connectTimeout,
			ackTimeout,
			multiplex: false,
			autoConnect: false,
			autoReconnect: false,
			pingTimeoutDisabled: true,
		};

		const outboundSocket = socketClusterClient.create(clientOptions);

		this._bindHandlersToOutboundSocket(outboundSocket);

		return outboundSocket;
	}

const clientOptions: ClientOptionsUpdated = {
			hostname: this.ipAddress,
			port: this.wsPort,
			query: querystring.stringify({
				...this._serverNodeInfo,
				options: JSON.stringify(this._serverNodeInfo),
			}),
			connectTimeout,
			ackTimeout,
			multiplex: false,
			autoConnect: false,
			autoReconnect: false,
			maxPayload: this._peerConfig.wsMaxPayload,
		};

		const outboundSocket = socketClusterClient.create(clientOptions);

		this._bindHandlersToOutboundSocket(outboundSocket);

		return outboundSocket;
	}

function connectToServer(options) {
  if (socket) return;
  let socketOptions;
  if (options.port) {
    socketOptions = {
      port: options.port,
      hostname: getHostForRN(options.hostname || 'localhost'),
      secure: !!options.secure
    };
  } else socketOptions = defaultSocketOptions;
  socket = socketCluster.create(socketOptions);
  watch();
}