@param array $blkioDeviceWriteIOps

@return Client
358447
public function setBlkioDeviceWriteIOps(array $blkioDeviceWriteIOps)
    {
        $this->blkioDeviceWriteIOps = $blkioDeviceWriteIOps;

        $this->hostConfig = array_merge($this->hostConfig, ['BlkioDeviceWriteIOps' => $blkioDeviceWriteIOps]);

        return $this;
    }
689857
protected function createClient($identifier)
    {
        if (!class_exists($identifier)) {
            return $this->createBuiltinClient($identifier);
        }

        return $this->createCustomClient($identifier);
    }
704289
protected function createClient()
    {
        $client = new MultiCurl();

        $credentials     = $this->getCredentials();
        $isAuthenticated = $credentials instanceof SSLCertificate;

        $client->setVerifyPeer($isAuthenticated);

        if ($isAuthenticated) {
            $client->setOption(CURLOPT_SSLCERT, $credentials->getCertificatePassPhrase());
            $client->setOption(CURLOPT_SSLCERTPASSWD, $credentials->getCertificatePassPhrase());
        }

        $this->serviceClient = new Browser($client);

        return $this;
    }
183427
public static function connectSubscriptions($customerUUID, array $data = [], ClientInterface $client = null)
    {
        (new static([], $client))
            ->getClient()
            ->setResourcekey(static::class)
            ->send('/v1/customers/'.$customerUUID.'/connect_subscriptions', 'POST', $data);
        return true;
    }
457117
public static function registerPlugins(KinveyClient $client, $plugins = array())
	{
		$plugins = array(
			new KinveyAuthPlugin(),
			new KinveyEntityCreateWithIDPlugin(),
			new KinveyCollectionNamePlugin(),
			new KinveyFileMetadataPlugin(),
			new KinveyEntityPathRewritePlugin(),
			new KinveyUserSoftDeletePlugin(),
			new KinveyRemoveInternalDataPlugin(),
			new KinveyInjectEntityIdPlugin(),
			new KinveyExceptionPlugin(new KinveyResponseExceptionFactory()),
			self::getExponentialBackoffPlugin(
				2,
				array('BLTimeoutError', 'KinveyInternalErrorRetry')
			)
		);

		if ($client->getConfig('logging')) $plugins[] = self::getLogPlugin(Log::getMonolog());

		foreach ($plugins as $plugin) $client->addSubscriber($plugin);

		return $client;
	}
1365699
public function delShopWifi($bssid)
    {
        $url = 'https://api.weixin.qq.com/bizwifi/device/delete?access_token=ACCESS_TOKEN';
        $this->registerApi($url, __FUNCTION__, func_get_args());
        return $this->httpPostForJson($url, ['bssid' => $bssid]);
    }
1027793
public function newClient(LoopInterface $loop = null)
    {
        return new Client($this->getConfig('realm'), $this->getRegisteredProviders(), $loop);
    }
936428
public function getSsoLink($writerId, $pid, $email)
    {
        $result = $this->getCommand('GetSSOLink', [
            'writerId' => $writerId,
            'pid' => $pid,
            'email' => $email
        ])->execute();
        if (!isset($result['ssoLink'])) {
            throw new ClientException('Getting SSO link failed. ' . (isset($result['error']) ? $result['error'] : ''));
        }
        return $result['ssoLink'];
    }
604867
public static function register(Uuid $id, $name, Chips $chips = null): Client
    {
        return new static($id, $name, $chips);
    }
428984
public function build(): SetFileInputFilesRequest
	{
		$instance = new SetFileInputFilesRequest();
		if ($this->files === null) {
			throw new BuilderException('Property [files] is required.');
		}
		$instance->files = $this->files;
		$instance->nodeId = $this->nodeId;
		$instance->backendNodeId = $this->backendNodeId;
		$instance->objectId = $this->objectId;
		return $instance;
	}
391144
public function create($data, $apiKeyId = null)
    {
        if (isset($apiKeyId)) {
            return $this->client()->put($data, 'api-keys/{apiKeyId}', ['apiKeyId' => $apiKeyId]);
        }

        return $this->client()->post($data, 'api-keys');
    }
623031
public static function factory($host, $port, $sendTimeout = null, $receiveTimeout = null, $framedTransport = false)
    {
        $socket = self::createSocket($host, $port, $sendTimeout, $receiveTimeout);
        $transport = self::createTransport($socket, $framedTransport);
        $protocol = new TBinaryProtocolAccelerated($transport);
        $client = new RestClient($protocol);
        $transport->open();

        return $client;
    }
214982
public function build(): PushNodesByBackendIdsToFrontendRequest
	{
		$instance = new PushNodesByBackendIdsToFrontendRequest();
		if ($this->backendNodeIds === null) {
			throw new BuilderException('Property [backendNodeIds] is required.');
		}
		$instance->backendNodeIds = $this->backendNodeIds;
		return $instance;
	}
554368
public DevicePipe writeReadPipe(DeviceProxy deviceProxy, DevicePipe devicePipe) throws DevFailed {
        //  ToDo
        build_connection(deviceProxy);
        if (deviceProxy.idl_version<5)
            Except.throw_exception("TangoApi_NOT_SUPPORTED",
                    "Pipe not supported in IDL " + deviceProxy.idl_version);
        boolean done = false;
        final int retries = deviceProxy.transparent_reconnection ? 2 : 1;
        for (int tr = 0 ; tr<retries && !done ; tr++) {
            try {
                DevPipeData writePipeData = devicePipe.getDevPipeDataObject();
                DevPipeData readPipeData = deviceProxy.device_5.write_read_pipe_5(
                        writePipeData, DevLockManager.getInstance().getClntIdent());
                done = true;
                return new DevicePipe(readPipeData);
            } catch (final DevFailed e) {
                throw e;
            } catch (final Exception e) {
                manageExceptionReconnection(deviceProxy, retries, tr, e,
                        this.getClass() + ".DeviceProxy.writePipe");
            }
        }
        return null;    //  cannot occur
    }
651113
public static function setKey($key, ClientInterface $client = null)
	{
		self::$api = new Api($key, $client);

		return self::$api;
	}
890508
public static function make(array $options = [], int $backoff = null, array $codes = null)
    {
        $config = array_merge(['connect_timeout' => self::CONNECT_TIMEOUT, 'timeout' => self::TIMEOUT], $options);
        $config['handler'] = self::handler($backoff, $codes, $options['handler'] ?? null);

        return new Client($config);
    }
748805
protected function _writeLine($data = null)
    {
        if ($data !== null) {
            if (fwrite($this->_socket, $data) === false) {
                throw new TransmitException(['send data failed: :url', 'url' => $this->_url]);
            }
            file_put_contents($this->_file, $data, FILE_APPEND);
        }

        file_put_contents($this->_file, PHP_EOL, FILE_APPEND);

        if (fwrite($this->_socket, "\r\n") === false) {
            throw new TransmitException(['send data failed: :url', 'url' => $this->_url]);
        }

        return $this;
    }