Correct spelling with this alias

@param $WaitTime
@param string $KeyOrder
@param int $KeyLength
@param string $KeyData
@param string $WithRemoveMsg
@return bool
488956
public function receiveDataQueue($WaitTime, $KeyOrder = '', $KeyLength = 0, $KeyData = '', $WithRemoveMsg = 'N')
    {
        // call misspelled one
        return $this->receieveDataQueue($WaitTime, $KeyOrder, $KeyLength, $KeyData, $WithRemoveMsg);
    }
915862
public static function importEncryptionSecretKey(HiddenString $keyData): EncryptionSecretKey
    {
        return new EncryptionSecretKey(
            new HiddenString(
                self::getKeyDataFromString(
                    Hex::decode($keyData->getString())
                )
            )
        );
    }
94401
public function wait($terminationCallback = null, $addToCompletedQueue = true)
    {
        $lastProcessesRunningCount = $currentRunningProcessesCount = $this->countRunning();
        while ($currentRunningProcessesCount > 0) {
            $currentRunningProcessesCount = $this->countRunning();
            if ($lastProcessesRunningCount !== $currentRunningProcessesCount) {
                $lastProcessesRunningCount = $currentRunningProcessesCount;
                $this->cleanUP($addToCompletedQueue);
                if (null !== $terminationCallback) {
                    call_user_func($terminationCallback);
                }
            }
            usleep(1000);
        }

        return true;
    }
18960
public function formatParameters(array $parameters, $keyString = null, $nested = false)
    {
        foreach ($parameters as $key => $value) {
            if (null !== $keyString && true === $nested) {
                $keyString = sprintf('%s[%s]', $keyString, $key);
            } else {
                $keyString = $key;
            }

            if (is_array($value)) {
                $this->formatParameters($value, $keyString, true);

                continue;
            } else {
                $this->formatedParameters[$keyString] = $value;
            }
        }

        return $this->formatedParameters;
    }
725106
public synchronized void enter(long waitTime) {

        if (m_singleUse && m_released) {
            return;
        }

        try {
            wait(waitTime);
        } catch (InterruptedException e) {
            // should never happen, but log it just in case...
            LOG.error(e.getLocalizedMessage(), e);
        }
    }
1333823
public function commit($expungeDeletes = false, $waitFlush = null, $waitSearcher = true, $timeout = 3600)
    {
        if ($waitFlush) {
            user_error('waitFlush must be false when using Solr 4.0+' . E_USER_ERROR);
        }

        $expungeValue = $expungeDeletes ? 'true' : 'false';
        $searcherValue = $waitSearcher ? 'true' : 'false';

        $rawPost = '<commit expungeDeletes="' . $expungeValue . '" waitSearcher="' . $searcherValue . '" />';
        return $this->_sendRawPost($this->_updateUrl, $rawPost, $timeout);
    }
690453
protected function receiveMessageBatch($maxCount = 1,
                                           $wait = null,
                                           $visibilityTimeout = null,
                                           $metas = [],
                                           $messageAttributes = [])
    {
        if ($maxCount > 10 || $maxCount < 1) {
            throw new \InvalidArgumentException("Max count for SQS message receiving is 10");
        }
        
        $messageAttributes[] = self::SERIALIZATION_FLAG;
        
        $args = [
            "QueueUrl"              => $this->getQueueUrl(),
            "MaxNumberOfMessages"   => $maxCount,
            'MessageAttributeNames' => $messageAttributes,
        ];
        if ($wait !== null && is_int($wait)) {
            $args['WaitTimeSeconds'] = $wait;
        }
        if ($visibilityTimeout !== null && is_int($visibilityTimeout)) {
            $args['VisibilityTimeout'] = $visibilityTimeout;
        }
        if ($metas && is_array($metas)) {
            $args['AttributeNames'] = $metas;
        }
        
        $result   = $this->client->receiveMessage($args);
        $messages = $result['Messages'];
        if (!$messages) {
            return [];
        }
        
        $ret = [];
        foreach ($messages as $data) {
            $msg   = new SqsReceivedMessage($data);
            $ret[] = $msg;
        }
        
        return $ret;
    }
979408
protected function success($msg = '', $url = '', $data = '', $wait = 3)
    {
        return $this->jump(1, $msg, $url, $data, $wait);
    }
121832
public function delete($key, $onResponse = null, $time = 0)
    {
        $this->getConnectionByKey($key, function ($conn) use ($key, $time, $onResponse) {
            if (!$conn->connected) {
                return;
            }
            if ($onResponse !== null) {
                $conn->onResponse->push($onResponse);
                $conn->checkFree();
            }
            $conn->writeln('delete ' . $this->config->prefix->value . $key . ' ' . $time);
        });
    }
701757
protected function callCallback($stream, $callback, $waitTime = 250)
    {
        if (!is_callable($callback)) {
            throw new \InvalidArgumentException('$callback must be a callable');
        }

        $stdio  = ssh2_fetch_stream($stream, SSH2_STREAM_STDIO);
        $stderr = ssh2_fetch_stream($stream, SSH2_STREAM_STDERR);

        if ($this->isInBlock) {
            stream_set_blocking($stdio, 0);
            stream_set_blocking($stderr, 0);

            do {
                // Hacky way to retrieve ssh stream, which is not select()able
                usleep($waitTime * 1000);
                $io  = stream_get_contents($stdio);
                $err = stream_get_contents($stderr);
                if ($io || $err) {
                    call_user_func($callback, $io, $err);
                }
            } while ($io || $err);

            return $this;
        }

        stream_set_blocking($stdio, 1);
        stream_set_blocking($stderr, 1);
        call_user_func($callback, stream_get_contents($stdio), stream_get_contents($stderr));

        return $this;
    }
90707
public static function formatJump($code, $msg = '', $url = '', $data = '', $wait = 3)
    {
        return array(
            'code' => $code,
            'msg' => $msg,
            'url' => $url,
            'data' => $data,
            'wait' => $wait
        );
    }
1228449
protected function _computeFinalKey($key1, $key2, $data)
    {
        if (mb_orig_strlen($data) < 8) {
            Daemon::$process->log(get_class($this) . '::' . __METHOD__ . ' : Invalid handshake data for client "' . $this->addr . '"');
            return false;
        }
        return md5($this->_computeKey($key1) . $this->_computeKey($key2) . mb_orig_substr($data, 0, 8), true);
    }
873573
public function consumeMessages($queue, $callback, $flags = AMQP_NOPARAM)
    {
        if (!isset($this->_queues[$queue])) {
            throw new InvalidKeyException(['consume message from queue failed: `:queue queue is NOT exists`', 'queue' => $queue]);
        }

        try {
            $this->_queues[$queue]->consume(function (\AMQPEnvelope $envelope) use ($callback, $queue) {
                return $callback(new Message($this, $queue, $envelope));
            }, $flags);
        } catch (\Exception $e) {
            throw new AmqpException('consume `:queue` queue message failed: ', $e->getMessage());
        }
    }
731721
public function waitForText($text, $seconds = null)
    {
        $text = Arr::wrap($text);

        $message = $this->formatTimeOutMessage('Waited %s seconds for text', implode("', '", $text));

        return $this->waitUsing($seconds, 100, function () use ($text) {
            return Str::contains($this->resolver->findOrFail('')->getText(), $text);
        }, $message);
    }
438358
protected function cap($waitTime)
    {
        return is_int($this->getWaitCap())
            ? min($this->getWaitCap(), $waitTime)
            : $waitTime;
    }
275383
public function waitUntilMissing($selector, $seconds = null)
    {
        $message = $this->formatTimeOutMessage('Waited %s seconds for removal of selector', $selector);

        return $this->waitUsing($seconds, 100, function () use ($selector) {
            try {
                $missing = ! $this->resolver->findOrFail($selector)->isDisplayed();
            } catch (NoSuchElementException $e) {
                $missing = true;
            }

            return $missing;
        }, $message);
    }
863591
static function sortByExternalKeys($dataArray, $keysArray) {
		$returnArray = array();
		foreach($keysArray as $k) {
			if (isset($dataArray[$k])) {
				$returnArray[$k] = $dataArray[$k];
			} else {
				$returnArray[$k] = null;
			}
		}
		return $returnArray;
	}