first commit

vendor/guzzlehttp/guzzle-services/src/Description.php

@@ -0,0 +1,265 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle;
+
+use GuzzleHttp\Psr7\Uri;
+
+/**
+ * Represents a Guzzle service description
+ */
+class Description implements DescriptionInterface
+{
+    /** @var array Array of {@see OperationInterface} objects */
+    private $operations = [];
+
+    /** @var array Array of API models */
+    private $models = [];
+
+    /** @var string Name of the API */
+    private $name;
+
+    /** @var string API version */
+    private $apiVersion;
+
+    /** @var string Summary of the API */
+    private $description;
+
+    /** @var array Any extra API data */
+    private $extraData = [];
+
+    /** @var Uri baseUri/basePath */
+    private $baseUri;
+
+    /** @var SchemaFormatter */
+    private $formatter;
+
+    /**
+     * @param array $config  Service description data
+     * @param array $options Custom options to apply to the description
+     *     - formatter: Can provide a custom SchemaFormatter class
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function __construct(array $config, array $options = [])
+    {
+        // Keep a list of default keys used in service descriptions that is
+        // later used to determine extra data keys.
+        static $defaultKeys = ['name', 'models', 'apiVersion', 'description'];
+
+        // Pull in the default configuration values
+        foreach ($defaultKeys as $key) {
+            if (isset($config[$key])) {
+                $this->{$key} = $config[$key];
+            }
+        }
+
+        // Set the baseUri
+        // Account for the old style of using baseUrl
+        if (isset($config['baseUrl'])) {
+            $config['baseUri'] = $config['baseUrl'];
+        }
+        $this->baseUri = isset($config['baseUri']) ? new Uri($config['baseUri']) : new Uri();
+
+        // Ensure that the models and operations properties are always arrays
+        $this->models = (array) $this->models;
+        $this->operations = (array) $this->operations;
+
+        // We want to add operations differently than adding the other properties
+        $defaultKeys[] = 'operations';
+
+        // Create operations for each operation
+        if (isset($config['operations'])) {
+            foreach ($config['operations'] as $name => $operation) {
+                if (!is_array($operation)) {
+                    throw new \InvalidArgumentException('Operations must be arrays');
+                }
+                $this->operations[$name] = $operation;
+            }
+        }
+
+        // Get all of the additional properties of the service description and
+        // store them in a data array
+        foreach (array_diff(array_keys($config), $defaultKeys) as $key) {
+            $this->extraData[$key] = $config[$key];
+        }
+
+        // Configure the schema formatter
+        if (isset($options['formatter'])) {
+            $this->formatter = $options['formatter'];
+        } else {
+            static $defaultFormatter;
+            if (!$defaultFormatter) {
+                $defaultFormatter = new SchemaFormatter();
+            }
+            $this->formatter = $defaultFormatter;
+        }
+    }
+
+    /**
+     * Get the basePath/baseUri of the description
+     *
+     * @return Uri
+     */
+    public function getBaseUri()
+    {
+        return $this->baseUri;
+    }
+
+    /**
+     * Get the API operations of the service
+     *
+     * @return Operation[] Returns an array of {@see Operation} objects
+     */
+    public function getOperations()
+    {
+        return $this->operations;
+    }
+
+    /**
+     * Check if the service has an operation by name
+     *
+     * @param string $name Name of the operation to check
+     *
+     * @return bool
+     */
+    public function hasOperation($name)
+    {
+        return isset($this->operations[$name]);
+    }
+
+    /**
+     * Get an API operation by name
+     *
+     * @param string $name Name of the command
+     *
+     * @return Operation
+     * @throws \InvalidArgumentException if the operation is not found
+     */
+    public function getOperation($name)
+    {
+        if (!$this->hasOperation($name)) {
+            throw new \InvalidArgumentException("No operation found named $name");
+        }
+
+        // Lazily create operations as they are retrieved
+        if (!($this->operations[$name] instanceof Operation)) {
+            $this->operations[$name]['name'] = $name;
+            $this->operations[$name] = new Operation($this->operations[$name], $this);
+        }
+
+        return $this->operations[$name];
+    }
+
+    /**
+     * Get a shared definition structure.
+     *
+     * @param string $id ID/name of the model to retrieve
+     *
+     * @return Parameter
+     * @throws \InvalidArgumentException if the model is not found
+     */
+    public function getModel($id)
+    {
+        if (!$this->hasModel($id)) {
+            throw new \InvalidArgumentException("No model found named $id");
+        }
+
+        // Lazily create models as they are retrieved
+        if (!($this->models[$id] instanceof Parameter)) {
+            $this->models[$id] = new Parameter(
+                $this->models[$id],
+                ['description' => $this]
+            );
+        }
+
+        return $this->models[$id];
+    }
+
+    /**
+     * Get all models of the service description.
+     *
+     * @return array
+     */
+    public function getModels()
+    {
+        $models = [];
+        foreach ($this->models as $name => $model) {
+            $models[$name] = $this->getModel($name);
+        }
+
+        return $models;
+    }
+
+    /**
+     * Check if the service description has a model by name.
+     *
+     * @param string $id Name/ID of the model to check
+     *
+     * @return bool
+     */
+    public function hasModel($id)
+    {
+        return isset($this->models[$id]);
+    }
+
+    /**
+     * Get the API version of the service
+     *
+     * @return string
+     */
+    public function getApiVersion()
+    {
+        return $this->apiVersion;
+    }
+
+    /**
+     * Get the name of the API
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * Get a summary of the purpose of the API
+     *
+     * @return string
+     */
+    public function getDescription()
+    {
+        return $this->description;
+    }
+
+    /**
+     * Format a parameter using named formats.
+     *
+     * @param string $format Format to convert it to
+     * @param mixed  $input  Input string
+     *
+     * @return mixed
+     */
+    public function format($format, $input)
+    {
+        return $this->formatter->format($format, $input);
+    }
+
+    /**
+     * Get arbitrary data from the service description that is not part of the
+     * Guzzle service description specification.
+     *
+     * @param string $key Data key to retrieve or null to retrieve all extra
+     *
+     * @return null|mixed
+     */
+    public function getData($key = null)
+    {
+        if ($key === null) {
+            return $this->extraData;
+        } elseif (isset($this->extraData[$key])) {
+            return $this->extraData[$key];
+        } else {
+            return null;
+        }
+    }
+}

vendor/guzzlehttp/guzzle-services/src/DescriptionInterface.php

@@ -0,0 +1,107 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle;
+
+use GuzzleHttp\Psr7\Uri;
+
+interface DescriptionInterface
+{
+    /**
+     * Get the basePath/baseUri of the description
+     *
+     * @return Uri
+     */
+    public function getBaseUri();
+
+    /**
+     * Get the API operations of the service
+     *
+     * @return Operation[] Returns an array of {@see Operation} objects
+     */
+    public function getOperations();
+
+    /**
+     * Check if the service has an operation by name
+     *
+     * @param string $name Name of the operation to check
+     *
+     * @return bool
+     */
+    public function hasOperation($name);
+
+    /**
+     * Get an API operation by name
+     *
+     * @param string $name Name of the command
+     *
+     * @return Operation
+     * @throws \InvalidArgumentException if the operation is not found
+     */
+    public function getOperation($name);
+
+    /**
+     * Get a shared definition structure.
+     *
+     * @param string $id ID/name of the model to retrieve
+     *
+     * @return Parameter
+     * @throws \InvalidArgumentException if the model is not found
+     */
+    public function getModel($id);
+
+    /**
+     * Get all models of the service description.
+     *
+     * @return array
+     */
+    public function getModels();
+
+    /**
+     * Check if the service description has a model by name.
+     *
+     * @param string $id Name/ID of the model to check
+     *
+     * @return bool
+     */
+    public function hasModel($id);
+
+    /**
+     * Get the API version of the service
+     *
+     * @return string
+     */
+    public function getApiVersion();
+
+    /**
+     * Get the name of the API
+     *
+     * @return string
+     */
+    public function getName();
+
+    /**
+     * Get a summary of the purpose of the API
+     *
+     * @return string
+     */
+    public function getDescription();
+
+    /**
+     * Format a parameter using named formats.
+     *
+     * @param string $format Format to convert it to
+     * @param mixed  $input  Input string
+     *
+     * @return mixed
+     */
+    public function format($format, $input);
+
+    /**
+     * Get arbitrary data from the service description that is not part of the
+     * Guzzle service description specification.
+     *
+     * @param string $key Data key to retrieve or null to retrieve all extra
+     *
+     * @return null|mixed
+     */
+    public function getData($key = null);
+}

vendor/guzzlehttp/guzzle-services/src/Deserializer.php

@@ -0,0 +1,294 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle;
+
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Guzzle\ResponseLocation\BodyLocation;
+use GuzzleHttp\Command\Guzzle\ResponseLocation\HeaderLocation;
+use GuzzleHttp\Command\Guzzle\ResponseLocation\JsonLocation;
+use GuzzleHttp\Command\Guzzle\ResponseLocation\ReasonPhraseLocation;
+use GuzzleHttp\Command\Guzzle\ResponseLocation\ResponseLocationInterface;
+use GuzzleHttp\Command\Guzzle\ResponseLocation\StatusCodeLocation;
+use GuzzleHttp\Command\Guzzle\ResponseLocation\XmlLocation;
+use GuzzleHttp\Command\Result;
+use GuzzleHttp\Command\ResultInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Handler used to create response models based on an HTTP response and
+ * a service description.
+ *
+ * Response location visitors are registered with this Handler to handle
+ * locations (e.g., 'xml', 'json', 'header'). All of the locations of a response
+ * model that will be visited first have their ``before`` method triggered.
+ * After the before method is called on every visitor that will be walked, each
+ * visitor is triggered using the ``visit()`` method. After all of the visitors
+ * are visited, the ``after()`` method is called on each visitor. This is the
+ * place in which you should handle things like additionalProperties with
+ * custom locations (i.e., this is how it is handled in the JSON visitor).
+ */
+class Deserializer
+{
+    /** @var ResponseLocationInterface[] $responseLocations */
+    private $responseLocations;
+
+    /** @var DescriptionInterface $description */
+    private $description;
+
+    /** @var boolean $process */
+    private $process;
+
+    /**
+     * @param DescriptionInterface $description
+     * @param bool $process
+     * @param ResponseLocationInterface[] $responseLocations Extra response locations
+     */
+    public function __construct(
+        DescriptionInterface $description,
+        $process,
+        array $responseLocations = []
+    ) {
+        static $defaultResponseLocations;
+        if (!$defaultResponseLocations) {
+            $defaultResponseLocations = [
+                'body'         => new BodyLocation(),
+                'header'       => new HeaderLocation(),
+                'reasonPhrase' => new ReasonPhraseLocation(),
+                'statusCode'   => new StatusCodeLocation(),
+                'xml'          => new XmlLocation(),
+                'json'         => new JsonLocation(),
+            ];
+        }
+
+        $this->responseLocations = $responseLocations + $defaultResponseLocations;
+        $this->description = $description;
+        $this->process = $process;
+    }
+
+    /**
+     * Deserialize the response into the specified result representation
+     *
+     * @param ResponseInterface     $response
+     * @param RequestInterface|null $request
+     * @param CommandInterface      $command
+     * @return Result|ResultInterface|void|ResponseInterface
+     */
+    public function __invoke(ResponseInterface $response, RequestInterface $request, CommandInterface $command)
+    {
+        // If the user don't want to process the result, just return the plain response here
+        if ($this->process === false) {
+            return $response;
+        }
+
+        $name = $command->getName();
+        $operation = $this->description->getOperation($name);
+
+        $this->handleErrorResponses($response, $request, $command, $operation);
+
+        // Add a default Model as the result if no matching schema was found
+        if (!($modelName = $operation->getResponseModel())) {
+            // Not sure if this should be empty or contains the response.
+            // Decided to do it how it was in the old version for now.
+            return new Result();
+        }
+
+        $model = $operation->getServiceDescription()->getModel($modelName);
+        if (!$model) {
+            throw new \RuntimeException("Unknown model: {$modelName}");
+        }
+
+        return $this->visit($model, $response);
+    }
+
+    /**
+     * Handles visit() and after() methods of the Response locations
+     *
+     * @param Parameter         $model
+     * @param ResponseInterface $response
+     * @return Result|ResultInterface|void
+     */
+    protected function visit(Parameter $model, ResponseInterface $response)
+    {
+        $result = new Result();
+        $context = ['visitors' => []];
+
+        if ($model->getType() === 'object') {
+            $result = $this->visitOuterObject($model, $result, $response, $context);
+        } elseif ($model->getType() === 'array') {
+            $result = $this->visitOuterArray($model, $result, $response, $context);
+        } else {
+            throw new \InvalidArgumentException('Invalid response model: ' . $model->getType());
+        }
+
+        // Call the after() method of each found visitor
+        /** @var ResponseLocationInterface $visitor */
+        foreach ($context['visitors'] as $visitor) {
+            $result = $visitor->after($result, $response, $model);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Handles the before() method of Response locations
+     *
+     * @param string            $location
+     * @param Parameter         $model
+     * @param ResultInterface   $result
+     * @param ResponseInterface $response
+     * @param array             $context
+     * @return ResultInterface
+     */
+    private function triggerBeforeVisitor(
+        $location,
+        Parameter $model,
+        ResultInterface $result,
+        ResponseInterface $response,
+        array &$context
+    ) {
+        if (!isset($this->responseLocations[$location])) {
+            throw new \RuntimeException("Unknown location: $location");
+        }
+
+        $context['visitors'][$location] = $this->responseLocations[$location];
+
+        $result = $this->responseLocations[$location]->before(
+            $result,
+            $response,
+            $model
+        );
+
+        return $result;
+    }
+
+    /**
+     * Visits the outer object
+     *
+     * @param Parameter         $model
+     * @param ResultInterface   $result
+     * @param ResponseInterface $response
+     * @param array             $context
+     * @return ResultInterface
+     */
+    private function visitOuterObject(
+        Parameter $model,
+        ResultInterface $result,
+        ResponseInterface $response,
+        array &$context
+    ) {
+        $parentLocation = $model->getLocation();
+
+        // If top-level additionalProperties is a schema, then visit it
+        $additional = $model->getAdditionalProperties();
+        if ($additional instanceof Parameter) {
+            // Use the model location if none set on additionalProperties.
+            $location = $additional->getLocation() ?: $parentLocation;
+            $result = $this->triggerBeforeVisitor($location, $model, $result, $response, $context);
+        }
+
+        // Use 'location' from all individual defined properties, but fall back
+        // to the model location if no per-property location is set. Collect
+        // the properties that need to be visited into an array.
+        $visitProperties = [];
+        foreach ($model->getProperties() as $schema) {
+            $location = $schema->getLocation() ?: $parentLocation;
+            if ($location) {
+                $visitProperties[] = [$location, $schema];
+                // Trigger the before method on each unique visitor location
+                if (!isset($context['visitors'][$location])) {
+                    $result = $this->triggerBeforeVisitor($location, $model, $result, $response, $context);
+                }
+            }
+        }
+
+        // Actually visit each response element
+        foreach ($visitProperties as $property) {
+            $result = $this->responseLocations[$property[0]]->visit($result, $response, $property[1]);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Visits the outer array
+     *
+     * @param Parameter         $model
+     * @param ResultInterface   $result
+     * @param ResponseInterface $response
+     * @param array             $context
+     * @return ResultInterface|void
+     */
+    private function visitOuterArray(
+        Parameter $model,
+        ResultInterface $result,
+        ResponseInterface $response,
+        array &$context
+    ) {
+        // Use 'location' defined on the top of the model
+        if (!($location = $model->getLocation())) {
+            return;
+        }
+
+        // Trigger the before method on each unique visitor location
+        if (!isset($context['visitors'][$location])) {
+            $result = $this->triggerBeforeVisitor($location, $model, $result, $response, $context);
+        }
+
+        // Visit each item in the response
+        $result = $this->responseLocations[$location]->visit($result, $response, $model);
+
+        return $result;
+    }
+
+    /**
+     * Reads the "errorResponses" from commands, and trigger appropriate exceptions
+     *
+     * In order for the exception to be properly triggered, all your exceptions must be instance
+     * of "GuzzleHttp\Command\Exception\CommandException". If that's not the case, your exceptions will be wrapped
+     * around a CommandException
+     *
+     * @param ResponseInterface $response
+     * @param RequestInterface  $request
+     * @param CommandInterface  $command
+     * @param Operation         $operation
+     */
+    protected function handleErrorResponses(
+        ResponseInterface $response,
+        RequestInterface $request,
+        CommandInterface $command,
+        Operation $operation
+    ) {
+        $errors = $operation->getErrorResponses();
+
+        // We iterate through each errors in service description. If the descriptor contains both a phrase and
+        // status code, there must be an exact match of both. Otherwise, a match of status code is enough
+        $bestException = null;
+
+        foreach ($errors as $error) {
+            $code = (int) $error['code'];
+
+            if ($response->getStatusCode() !== $code) {
+                continue;
+            }
+
+            if (isset($error['phrase']) && ! ($error['phrase'] === $response->getReasonPhrase())) {
+                continue;
+            }
+
+            $bestException = $error['class'];
+
+            // If there is an exact match of phrase + code, then we cannot find a more specialized exception in
+            // the array, so we can break early instead of iterating the remaining ones
+            if (isset($error['phrase'])) {
+                break;
+            }
+        }
+
+        if (null !== $bestException) {
+            throw new $bestException($response->getReasonPhrase(), $command, null, $request, $response);
+        }
+
+        // If we reach here, no exception could be match from descriptor, and Guzzle exception will propagate if
+        // option "http_errors" is set to true, which is the default setting.
+    }
+}

vendor/guzzlehttp/guzzle-services/src/GuzzleClient.php

@@ -0,0 +1,169 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle;
+
+use GuzzleHttp\ClientInterface;
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Guzzle\Handler\ValidatedDescriptionHandler;
+use GuzzleHttp\Command\ServiceClient;
+use GuzzleHttp\HandlerStack;
+
+/**
+ * Default Guzzle web service client implementation.
+ */
+class GuzzleClient extends ServiceClient
+{
+    /** @var array $config */
+    private $config;
+
+    /** @var DescriptionInterface Guzzle service description */
+    private $description;
+
+    /**
+     * The client constructor accepts an associative array of configuration
+     * options:
+     *
+     * - defaults: Associative array of default command parameters to add to
+     *   each command created by the client.
+     * - validate: Specify if command input is validated (defaults to true).
+     *   Changing this setting after the client has been created will have no
+     *   effect.
+     * - process: Specify if HTTP responses are parsed (defaults to true).
+     *   Changing this setting after the client has been created will have no
+     *   effect.
+     * - response_locations: Associative array of location types mapping to
+     *   ResponseLocationInterface objects.
+     *
+     * @param ClientInterface $client HTTP client to use.
+     * @param DescriptionInterface $description Guzzle service description
+     * @param callable $commandToRequestTransformer
+     * @param callable $responseToResultTransformer
+     * @param HandlerStack $commandHandlerStack
+     * @param array $config Configuration options
+     */
+    public function __construct(
+        ClientInterface $client,
+        DescriptionInterface $description,
+        callable $commandToRequestTransformer = null,
+        callable $responseToResultTransformer = null,
+        HandlerStack $commandHandlerStack = null,
+        array $config = []
+    ) {
+        $this->config = $config;
+        $this->description = $description;
+        $serializer = $this->getSerializer($commandToRequestTransformer);
+        $deserializer = $this->getDeserializer($responseToResultTransformer);
+
+        parent::__construct($client, $serializer, $deserializer, $commandHandlerStack);
+        $this->processConfig($config);
+    }
+
+    /**
+     * Returns the command if valid; otherwise an Exception
+     * @param string $name
+     * @param array  $args
+     * @return CommandInterface
+     * @throws \InvalidArgumentException
+     */
+    public function getCommand($name, array $args = [])
+    {
+        if (!$this->description->hasOperation($name)) {
+            $name = ucfirst($name);
+            if (!$this->description->hasOperation($name)) {
+                throw new \InvalidArgumentException(
+                    "No operation found named {$name}"
+                );
+            }
+        }
+
+        // Merge in default command options
+        $args += $this->getConfig('defaults');
+
+        return parent::getCommand($name, $args);
+    }
+
+    /**
+     * Return the description
+     *
+     * @return DescriptionInterface
+     */
+    public function getDescription()
+    {
+        return $this->description;
+    }
+
+    /**
+     * Returns the passed Serializer when set, a new instance otherwise
+     *
+     * @param callable|null $commandToRequestTransformer
+     * @return \GuzzleHttp\Command\Guzzle\Serializer
+     */
+    private function getSerializer($commandToRequestTransformer)
+    {
+        return $commandToRequestTransformer !== null
+            ? $commandToRequestTransformer
+            : new Serializer($this->description);
+    }
+
+    /**
+     * Returns the passed Deserializer when set, a new instance otherwise
+     *
+     * @param callable|null $responseToResultTransformer
+     * @return \GuzzleHttp\Command\Guzzle\Deserializer
+     */
+    private function getDeserializer($responseToResultTransformer)
+    {
+        $process = (! isset($this->config['process']) || $this->config['process'] === true);
+
+        return $responseToResultTransformer !== null
+            ? $responseToResultTransformer
+            : new Deserializer($this->description, $process);
+    }
+
+    /**
+     * Get the config of the client
+     *
+     * @param array|string $option
+     * @return mixed
+     */
+    public function getConfig($option = null)
+    {
+        return $option === null
+            ? $this->config
+            : (isset($this->config[$option]) ? $this->config[$option] : []);
+    }
+
+    /**
+     * @param $option
+     * @param $value
+     */
+    public function setConfig($option, $value)
+    {
+        $this->config[$option] = $value;
+    }
+
+    /**
+     * Prepares the client based on the configuration settings of the client.
+     *
+     * @param array $config Constructor config as an array
+     */
+    protected function processConfig(array $config)
+    {
+        // set defaults as an array if not provided
+        if (!isset($config['defaults'])) {
+            $config['defaults'] = [];
+        }
+
+        // Add the handlers based on the configuration option
+        $stack = $this->getHandlerStack();
+
+        if (!isset($config['validate']) || $config['validate'] === true) {
+            $stack->push(new ValidatedDescriptionHandler($this->description), 'validate_description');
+        }
+
+        if (!isset($config['process']) || $config['process'] === true) {
+            // TODO: This belongs to the Deserializer and should be handled there.
+            // Question: What is the result when the Deserializer is bypassed?
+            // Possible answer: The raw response.
+        }
+    }
+}

vendor/guzzlehttp/guzzle-services/src/Handler/ValidatedDescriptionHandler.php

@@ -0,0 +1,82 @@
+<?php namespace GuzzleHttp\Command\Guzzle\Handler;
+
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Exception\CommandException;
+use GuzzleHttp\Command\Guzzle\DescriptionInterface;
+use GuzzleHttp\Command\Guzzle\SchemaValidator;
+
+/**
+ * Handler used to validate command input against a service description.
+ *
+ * @author Stefano Kowalke <info@arroba-it.de>
+ */
+class ValidatedDescriptionHandler
+{
+    /** @var SchemaValidator $validator */
+    private $validator;
+
+    /** @var DescriptionInterface $description */
+    private $description;
+
+    /**
+     * ValidatedDescriptionHandler constructor.
+     *
+     * @param DescriptionInterface $description
+     * @param SchemaValidator|null $schemaValidator
+     */
+    public function __construct(DescriptionInterface $description, SchemaValidator $schemaValidator = null)
+    {
+        $this->description = $description;
+        $this->validator = $schemaValidator ?: new SchemaValidator();
+    }
+
+    /**
+     * @param callable $handler
+     * @return \Closure
+     */
+    public function __invoke(callable $handler)
+    {
+        return function (CommandInterface $command) use ($handler) {
+            $errors = [];
+            $operation = $this->description->getOperation($command->getName());
+
+            foreach ($operation->getParams() as $name => $schema) {
+                $value = $command[$name];
+
+                if ($value) {
+                    $value = $schema->filter($value);
+                }
+
+                if (! $this->validator->validate($schema, $value)) {
+                    $errors = array_merge($errors, $this->validator->getErrors());
+                } elseif ($value !== $command[$name]) {
+                    // Update the config value if it changed and no validation errors were encountered.
+                    // This happen when the user extending an operation
+                    // See https://github.com/guzzle/guzzle-services/issues/145
+                    $command[$name] = $value;
+                }
+            }
+
+            if ($params = $operation->getAdditionalParameters()) {
+                foreach ($command->toArray() as $name => $value) {
+                    // It's only additional if it isn't defined in the schema
+                    if (! $operation->hasParam($name)) {
+                        // Always set the name so that error messages are useful
+                        $params->setName($name);
+                        if (! $this->validator->validate($params, $value)) {
+                            $errors = array_merge($errors, $this->validator->getErrors());
+                        } elseif ($value !== $command[$name]) {
+                            $command[$name] = $value;
+                        }
+                    }
+                }
+            }
+
+            if ($errors) {
+                throw new CommandException('Validation errors: ' . implode("\n", $errors), $command);
+            }
+
+            return $handler($command);
+        };
+    }
+}

vendor/guzzlehttp/guzzle-services/src/Operation.php

@@ -0,0 +1,312 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle;
+
+use GuzzleHttp\Command\ToArrayInterface;
+
+/**
+ * Guzzle operation
+ */
+class Operation implements ToArrayInterface
+{
+    /** @var array Parameters */
+    private $parameters = [];
+
+    /** @var Parameter Additional parameters schema */
+    private $additionalParameters;
+
+    /** @var DescriptionInterface */
+    private $description;
+
+    /** @var array Config data */
+    private $config;
+
+    /**
+     * Builds an Operation object using an array of configuration data.
+     *
+     * - name: (string) Name of the command
+     * - httpMethod: (string) HTTP method of the operation
+     * - uri: (string) URI template that can create a relative or absolute URL
+     * - parameters: (array) Associative array of parameters for the command.
+     *   Each value must be an array that is used to create {@see Parameter}
+     *   objects.
+     * - summary: (string) This is a short summary of what the operation does
+     * - notes: (string) A longer description of the operation.
+     * - documentationUrl: (string) Reference URL providing more information
+     *   about the operation.
+     * - responseModel: (string) The model name used for processing response.
+     * - deprecated: (bool) Set to true if this is a deprecated command
+     * - errorResponses: (array) Errors that could occur when executing the
+     *   command. Array of hashes, each with a 'code' (the HTTP response code),
+     *   'phrase' (response reason phrase or description of the error), and
+     *   'class' (a custom exception class that would be thrown if the error is
+     *   encountered).
+     * - data: (array) Any extra data that might be used to help build or
+     *   serialize the operation
+     * - additionalParameters: (null|array) Parameter schema to use when an
+     *   option is passed to the operation that is not in the schema
+     *
+     * @param array                 $config      Array of configuration data
+     * @param DescriptionInterface  $description Service description used to resolve models if $ref tags are found
+     * @throws \InvalidArgumentException
+     */
+    public function __construct(array $config = [], DescriptionInterface $description = null)
+    {
+        static $defaults = [
+            'name' => '',
+            'httpMethod' => '',
+            'uri' => '',
+            'responseModel' => null,
+            'notes' => '',
+            'summary' => '',
+            'documentationUrl' => null,
+            'deprecated' => false,
+            'data' => [],
+            'parameters' => [],
+            'additionalParameters' => null,
+            'errorResponses' => []
+        ];
+
+        $this->description = $description === null ? new Description([]) : $description;
+
+        if (isset($config['extends'])) {
+            $config = $this->resolveExtends($config['extends'], $config);
+        }
+
+        $this->config = $config + $defaults;
+
+        // Account for the old style of using responseClass
+        if (isset($config['responseClass'])) {
+            $this->config['responseModel'] = $config['responseClass'];
+        }
+
+        $this->resolveParameters();
+    }
+
+    /**
+     * @return array
+     */
+    public function toArray()
+    {
+        return $this->config;
+    }
+
+    /**
+     * Get the service description that the operation belongs to
+     *
+     * @return Description
+     */
+    public function getServiceDescription()
+    {
+        return $this->description;
+    }
+
+    /**
+     * Get the params of the operation
+     *
+     * @return Parameter[]
+     */
+    public function getParams()
+    {
+        return $this->parameters;
+    }
+
+    /**
+     * Get additionalParameters of the operation
+     *
+     * @return Parameter|null
+     */
+    public function getAdditionalParameters()
+    {
+        return $this->additionalParameters;
+    }
+
+    /**
+     * Check if the operation has a specific parameter by name
+     *
+     * @param string $name Name of the param
+     *
+     * @return bool
+     */
+    public function hasParam($name)
+    {
+        return isset($this->parameters[$name]);
+    }
+
+    /**
+     * Get a single parameter of the operation
+     *
+     * @param string $name Parameter to retrieve by name
+     *
+     * @return Parameter|null
+     */
+    public function getParam($name)
+    {
+        return isset($this->parameters[$name])
+            ? $this->parameters[$name]
+            : null;
+    }
+
+    /**
+     * Get the HTTP method of the operation
+     *
+     * @return string|null
+     */
+    public function getHttpMethod()
+    {
+        return $this->config['httpMethod'];
+    }
+
+    /**
+     * Get the name of the operation
+     *
+     * @return string|null
+     */
+    public function getName()
+    {
+        return $this->config['name'];
+    }
+
+    /**
+     * Get a short summary of what the operation does
+     *
+     * @return string|null
+     */
+    public function getSummary()
+    {
+        return $this->config['summary'];
+    }
+
+    /**
+     * Get a longer text field to explain the behavior of the operation
+     *
+     * @return string|null
+     */
+    public function getNotes()
+    {
+        return $this->config['notes'];
+    }
+
+    /**
+     * Get the documentation URL of the operation
+     *
+     * @return string|null
+     */
+    public function getDocumentationUrl()
+    {
+        return $this->config['documentationUrl'];
+    }
+
+    /**
+     * Get the name of the model used for processing the response.
+     *
+     * @return string
+     */
+    public function getResponseModel()
+    {
+        return $this->config['responseModel'];
+    }
+
+    /**
+     * Get whether or not the operation is deprecated
+     *
+     * @return bool
+     */
+    public function getDeprecated()
+    {
+        return $this->config['deprecated'];
+    }
+
+    /**
+     * Get the URI that will be merged into the generated request
+     *
+     * @return string
+     */
+    public function getUri()
+    {
+        return $this->config['uri'];
+    }
+
+    /**
+     * Get the errors that could be encountered when executing the operation
+     *
+     * @return array
+     */
+    public function getErrorResponses()
+    {
+        return $this->config['errorResponses'];
+    }
+
+    /**
+     * Get extra data from the operation
+     *
+     * @param string $name Name of the data point to retrieve or null to
+     *     retrieve all of the extra data.
+     *
+     * @return mixed|null
+     */
+    public function getData($name = null)
+    {
+        if ($name === null) {
+            return $this->config['data'];
+        } elseif (isset($this->config['data'][$name])) {
+            return $this->config['data'][$name];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * @param $name
+     * @param array $config
+     * @return array
+     */
+    private function resolveExtends($name, array $config)
+    {
+        if (!$this->description->hasOperation($name)) {
+            throw new \InvalidArgumentException('No operation named ' . $name);
+        }
+
+        // Merge parameters together one level deep
+        $base = $this->description->getOperation($name)->toArray();
+        $result = $config + $base;
+
+        if (isset($base['parameters']) && isset($config['parameters'])) {
+            $result['parameters'] = $config['parameters'] + $base['parameters'];
+        }
+
+        return $result;
+    }
+
+    /**
+     * Process the description and extract the parameter config
+     *
+     * @return void
+     */
+    private function resolveParameters()
+    {
+        // Parameters need special handling when adding
+        foreach ($this->config['parameters'] as $name => $param) {
+            if (!is_array($param)) {
+                throw new \InvalidArgumentException(
+                    "Parameters must be arrays, {$this->config['name']}.$name is ".gettype($param)
+                );
+            }
+            $param['name'] = $name;
+            $this->parameters[$name] = new Parameter(
+                $param,
+                ['description' => $this->description]
+            );
+        }
+
+        if ($this->config['additionalParameters']) {
+            if (is_array($this->config['additionalParameters'])) {
+                $this->additionalParameters = new Parameter(
+                    $this->config['additionalParameters'],
+                    ['description' => $this->description]
+                );
+            } else {
+                $this->additionalParameters = $this->config['additionalParameters'];
+            }
+        }
+    }
+}

vendor/guzzlehttp/guzzle-services/src/Parameter.php

@@ -0,0 +1,655 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle;
+
+use GuzzleHttp\Command\ToArrayInterface;
+
+/**
+ * API parameter object used with service descriptions
+ */
+class Parameter implements ToArrayInterface
+{
+    private $originalData;
+
+    /** @var string $name */
+    private $name;
+
+    /** @var string $description */
+    private $description;
+
+    /** @var string|array $type */
+    private $type;
+
+    /** @var bool $required*/
+    private $required;
+
+    /** @var array|null $enum */
+    private $enum;
+
+    /** @var string $pattern */
+    private $pattern;
+
+    /** @var int $minimum*/
+    private $minimum;
+
+    /** @var int $maximum */
+    private $maximum;
+
+    /** @var int $minLength */
+    private $minLength;
+
+    /** @var int $maxLength */
+    private $maxLength;
+
+    /** @var int $minItems */
+    private $minItems;
+
+    /** @var int $maxItems */
+    private $maxItems;
+
+    /** @var mixed $default */
+    private $default;
+
+    /** @var bool $static */
+    private $static;
+
+    /** @var array $filters */
+    private $filters;
+
+    /** @var string $location */
+    private $location;
+
+    /** @var string $sentAs */
+    private $sentAs;
+
+    /** @var array $data */
+    private $data;
+
+    /** @var array $properties */
+    private $properties = [];
+
+    /** @var array|bool|Parameter $additionalProperties */
+    private $additionalProperties;
+
+    /** @var array|Parameter $items */
+    private $items;
+
+    /** @var string $format */
+    private $format;
+
+    private $propertiesCache = null;
+
+    /** @var Description */
+    private $serviceDescription;
+
+    /**
+     * Create a new Parameter using an associative array of data.
+     *
+     * The array can contain the following information:
+     *
+     * - name: (string) Unique name of the parameter
+     *
+     * - type: (string|array) Type of variable (string, number, integer,
+     *   boolean, object, array, numeric, null, any). Types are used for
+     *   validation and determining the structure of a parameter. You can use a
+     *   union type by providing an array of simple types. If one of the union
+     *   types matches the provided value, then the value is valid.
+     *
+     * - required: (bool) Whether or not the parameter is required
+     *
+     * - default: (mixed) Default value to use if no value is supplied
+     *
+     * - static: (bool) Set to true to specify that the parameter value cannot
+     *   be changed from the default.
+     *
+     * - description: (string) Documentation of the parameter
+     *
+     * - location: (string) The location of a request used to apply a parameter.
+     *   Custom locations can be registered with a command, but the defaults
+     *   are uri, query, header, body, json, xml, formParam, multipart.
+     *
+     * - sentAs: (string) Specifies how the data being modeled is sent over the
+     *   wire. For example, you may wish to include certain headers in a
+     *   response model that have a normalized casing of FooBar, but the actual
+     *   header is x-foo-bar. In this case, sentAs would be set to x-foo-bar.
+     *
+     * - filters: (array) Array of static method names to run a parameter
+     *   value through. Each value in the array must be a string containing the
+     *   full class path to a static method or an array of complex filter
+     *   information. You can specify static methods of classes using the full
+     *   namespace class name followed by '::' (e.g. Foo\Bar::baz). Some
+     *   filters require arguments in order to properly filter a value. For
+     *   complex filters, use a hash containing a 'method' key pointing to a
+     *   static method, and an 'args' key containing an array of positional
+     *   arguments to pass to the method. Arguments can contain keywords that
+     *   are replaced when filtering a value: '@value' is replaced with the
+     *   value being validated, '@api' is replaced with the Parameter object.
+     *
+     * - properties: When the type is an object, you can specify nested parameters
+     *
+     * - additionalProperties: (array) This attribute defines a schema for all
+     *   properties that are not explicitly defined in an object type
+     *   definition. If specified, the value MUST be a schema or a boolean. If
+     *   false is provided, no additional properties are allowed beyond the
+     *   properties defined in the schema. The default value is an empty schema
+     *   which allows any value for additional properties.
+     *
+     * - items: This attribute defines the allowed items in an instance array,
+     *   and MUST be a schema or an array of schemas. The default value is an
+     *   empty schema which allows any value for items in the instance array.
+     *   When this attribute value is a schema and the instance value is an
+     *   array, then all the items in the array MUST be valid according to the
+     *   schema.
+     *
+     * - pattern: When the type is a string, you can specify the regex pattern
+     *   that a value must match
+     *
+     * - enum: When the type is a string, you can specify a list of acceptable
+     *   values.
+     *
+     * - minItems: (int) Minimum number of items allowed in an array
+     *
+     * - maxItems: (int) Maximum number of items allowed in an array
+     *
+     * - minLength: (int) Minimum length of a string
+     *
+     * - maxLength: (int) Maximum length of a string
+     *
+     * - minimum: (int) Minimum value of an integer
+     *
+     * - maximum: (int) Maximum value of an integer
+     *
+     * - data: (array) Any additional custom data to use when serializing,
+     *   validating, etc
+     *
+     * - format: (string) Format used to coax a value into the correct format
+     *   when serializing or unserializing. You may specify either an array of
+     *   filters OR a format, but not both. Supported values: date-time, date,
+     *   time, timestamp, date-time-http, and boolean-string.
+     *
+     * - $ref: (string) String referencing a service description model. The
+     *   parameter is replaced by the schema contained in the model.
+     *
+     * @param array $data    Array of data as seen in service descriptions
+     * @param array $options Options used when creating the parameter. You can
+     *     specify a Guzzle service description in the 'description' key.
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function __construct(array $data = [], array $options = [])
+    {
+        $this->originalData = $data;
+
+        if (isset($options['description'])) {
+            $this->serviceDescription = $options['description'];
+            if (!($this->serviceDescription instanceof DescriptionInterface)) {
+                throw new \InvalidArgumentException('description must be a Description');
+            }
+            if (isset($data['$ref'])) {
+                if ($model = $this->serviceDescription->getModel($data['$ref'])) {
+                    $name = isset($data['name']) ? $data['name'] : null;
+                    $data = $model->toArray() + $data;
+                    if ($name) {
+                        $data['name'] = $name;
+                    }
+                }
+            } elseif (isset($data['extends'])) {
+                // If this parameter extends from another parameter then start
+                // with the actual data union in the parent's data (e.g. actual
+                // supersedes parent)
+                if ($extends = $this->serviceDescription->getModel($data['extends'])) {
+                    $data += $extends->toArray();
+                }
+            }
+        }
+
+        // Pull configuration data into the parameter
+        foreach ($data as $key => $value) {
+            $this->{$key} = $value;
+        }
+
+        $this->required = (bool) $this->required;
+        $this->data = (array) $this->data;
+
+        if ($this->filters) {
+            $this->setFilters((array) $this->filters);
+        }
+
+        if ($this->type == 'object' && $this->additionalProperties === null) {
+            $this->additionalProperties = true;
+        }
+    }
+
+    /**
+     * Convert the object to an array
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        return $this->originalData;
+    }
+
+    /**
+     * Get the default or static value of the command based on a value
+     *
+     * @param string $value Value that is currently set
+     *
+     * @return mixed Returns the value, a static value if one is present, or a default value
+     */
+    public function getValue($value)
+    {
+        if ($this->static || ($this->default !== null && $value === null)) {
+            return $this->default;
+        }
+
+        return $value;
+    }
+
+    /**
+     * Run a value through the filters OR format attribute associated with the
+     * parameter.
+     *
+     * @param mixed $value Value to filter
+     *
+     * @return mixed Returns the filtered value
+     * @throws \RuntimeException when trying to format when no service
+     *     description is available.
+     */
+    public function filter($value)
+    {
+        // Formats are applied exclusively and supersed filters
+        if ($this->format) {
+            if (!$this->serviceDescription) {
+                throw new \RuntimeException('No service description was set so '
+                    . 'the value cannot be formatted.');
+            }
+            return $this->serviceDescription->format($this->format, $value);
+        }
+
+        // Convert Boolean values
+        if ($this->type == 'boolean' && !is_bool($value)) {
+            $value = filter_var($value, FILTER_VALIDATE_BOOLEAN);
+        }
+
+        // Apply filters to the value
+        if ($this->filters) {
+            foreach ($this->filters as $filter) {
+                if (is_array($filter)) {
+                    // Convert complex filters that hold value place holders
+                    foreach ($filter['args'] as &$data) {
+                        if ($data == '@value') {
+                            $data = $value;
+                        } elseif ($data == '@api') {
+                            $data = $this;
+                        }
+                    }
+                    $value = call_user_func_array(
+                        $filter['method'],
+                        $filter['args']
+                    );
+                } else {
+                    $value = call_user_func($filter, $value);
+                }
+            }
+        }
+
+        return $value;
+    }
+
+    /**
+     * Get the name of the parameter
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * Set the name of the parameter
+     *
+     * @param string $name Name to set
+     */
+    public function setName($name)
+    {
+        $this->name = $name;
+    }
+
+    /**
+     * Get the key of the parameter, where sentAs will supersede name if it is
+     * set.
+     *
+     * @return string
+     */
+    public function getWireName()
+    {
+        return $this->sentAs ?: $this->name;
+    }
+
+    /**
+     * Get the type(s) of the parameter
+     *
+     * @return string|array
+     */
+    public function getType()
+    {
+        return $this->type;
+    }
+
+    /**
+     * Get if the parameter is required
+     *
+     * @return bool
+     */
+    public function isRequired()
+    {
+        return $this->required;
+    }
+
+    /**
+     * Get the default value of the parameter
+     *
+     * @return string|null
+     */
+    public function getDefault()
+    {
+        return $this->default;
+    }
+
+    /**
+     * Get the description of the parameter
+     *
+     * @return string|null
+     */
+    public function getDescription()
+    {
+        return $this->description;
+    }
+
+    /**
+     * Get the minimum acceptable value for an integer
+     *
+     * @return int|null
+     */
+    public function getMinimum()
+    {
+        return $this->minimum;
+    }
+
+    /**
+     * Get the maximum acceptable value for an integer
+     *
+     * @return int|null
+     */
+    public function getMaximum()
+    {
+        return $this->maximum;
+    }
+
+    /**
+     * Get the minimum allowed length of a string value
+     *
+     * @return int
+     */
+    public function getMinLength()
+    {
+        return $this->minLength;
+    }
+
+    /**
+     * Get the maximum allowed length of a string value
+     *
+     * @return int|null
+     */
+    public function getMaxLength()
+    {
+        return $this->maxLength;
+    }
+
+    /**
+     * Get the maximum allowed number of items in an array value
+     *
+     * @return int|null
+     */
+    public function getMaxItems()
+    {
+        return $this->maxItems;
+    }
+
+    /**
+     * Get the minimum allowed number of items in an array value
+     *
+     * @return int
+     */
+    public function getMinItems()
+    {
+        return $this->minItems;
+    }
+
+    /**
+     * Get the location of the parameter
+     *
+     * @return string|null
+     */
+    public function getLocation()
+    {
+        return $this->location;
+    }
+
+    /**
+     * Get the sentAs attribute of the parameter that used with locations to
+     * sentAs an attribute when it is being applied to a location.
+     *
+     * @return string|null
+     */
+    public function getSentAs()
+    {
+        return $this->sentAs;
+    }
+
+    /**
+     * Retrieve a known property from the parameter by name or a data property
+     * by name. When no specific name value is passed, all data properties
+     * will be returned.
+     *
+     * @param string|null $name Specify a particular property name to retrieve
+     *
+     * @return array|mixed|null
+     */
+    public function getData($name = null)
+    {
+        if (!$name) {
+            return $this->data;
+        } elseif (isset($this->data[$name])) {
+            return $this->data[$name];
+        } elseif (isset($this->{$name})) {
+            return $this->{$name};
+        }
+
+        return null;
+    }
+
+    /**
+     * Get whether or not the default value can be changed
+     *
+     * @return bool
+     */
+    public function isStatic()
+    {
+        return $this->static;
+    }
+
+    /**
+     * Get an array of filters used by the parameter
+     *
+     * @return array
+     */
+    public function getFilters()
+    {
+        return $this->filters ?: [];
+    }
+
+    /**
+     * Get the properties of the parameter
+     *
+     * @return Parameter[]
+     */
+    public function getProperties()
+    {
+        if (!$this->propertiesCache) {
+            $this->propertiesCache = [];
+            foreach (array_keys($this->properties) as $name) {
+                $this->propertiesCache[$name] = $this->getProperty($name);
+            }
+        }
+
+        return $this->propertiesCache;
+    }
+
+    /**
+     * Get a specific property from the parameter
+     *
+     * @param string $name Name of the property to retrieve
+     *
+     * @return null|Parameter
+     */
+    public function getProperty($name)
+    {
+        if (!isset($this->properties[$name])) {
+            return null;
+        }
+
+        if (!($this->properties[$name] instanceof self)) {
+            $this->properties[$name]['name'] = $name;
+            $this->properties[$name] = new static(
+                $this->properties[$name],
+                ['description' => $this->serviceDescription]
+            );
+        }
+
+        return $this->properties[$name];
+    }
+
+    /**
+     * Get the additionalProperties value of the parameter
+     *
+     * @return bool|Parameter|null
+     */
+    public function getAdditionalProperties()
+    {
+        if (is_array($this->additionalProperties)) {
+            $this->additionalProperties = new static(
+                $this->additionalProperties,
+                ['description' => $this->serviceDescription]
+            );
+        }
+
+        return $this->additionalProperties;
+    }
+
+    /**
+     * Get the item data of the parameter
+     *
+     * @return Parameter
+     */
+    public function getItems()
+    {
+        if (is_array($this->items)) {
+            $this->items = new static(
+                $this->items,
+                ['description' => $this->serviceDescription]
+            );
+        }
+
+        return $this->items;
+    }
+
+    /**
+     * Get the enum of strings that are valid for the parameter
+     *
+     * @return array|null
+     */
+    public function getEnum()
+    {
+        return $this->enum;
+    }
+
+    /**
+     * Get the regex pattern that must match a value when the value is a string
+     *
+     * @return string
+     */
+    public function getPattern()
+    {
+        return $this->pattern;
+    }
+
+    /**
+     * Get the format attribute of the schema
+     *
+     * @return string
+     */
+    public function getFormat()
+    {
+        return $this->format;
+    }
+
+    /**
+     * Set the array of filters used by the parameter
+     *
+     * @param array $filters Array of functions to use as filters
+     *
+     * @return self
+     */
+    private function setFilters(array $filters)
+    {
+        $this->filters = [];
+        foreach ($filters as $filter) {
+            $this->addFilter($filter);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Add a filter to the parameter
+     *
+     * @param string|array $filter Method to filter the value through
+     *
+     * @return self
+     * @throws \InvalidArgumentException
+     */
+    private function addFilter($filter)
+    {
+        if (is_array($filter)) {
+            if (!isset($filter['method'])) {
+                throw new \InvalidArgumentException(
+                    'A [method] value must be specified for each complex filter'
+                );
+            }
+        }
+
+        if (!$this->filters) {
+            $this->filters = [$filter];
+        } else {
+            $this->filters[] = $filter;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Check if a parameter has a specific variable and if it set.
+     *
+     * @param string $var
+     * @return bool
+     */
+    public function has($var)
+    {
+        if (!is_string($var)) {
+            throw new \InvalidArgumentException('Expected a string. Got: ' . (is_object($var) ? get_class($var) : gettype($var)));
+        }
+        return isset($this->{$var}) && !empty($this->{$var});
+    }
+}

vendor/guzzlehttp/guzzle-services/src/QuerySerializer/QuerySerializerInterface.php

@@ -0,0 +1,13 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\QuerySerializer;
+
+interface QuerySerializerInterface
+{
+    /**
+     * Aggregate query params and transform them into a string
+     *
+     * @param  array $queryParams
+     * @return string
+     */
+    public function aggregate(array $queryParams);
+}

vendor/guzzlehttp/guzzle-services/src/QuerySerializer/Rfc3986Serializer.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace GuzzleHttp\Command\Guzzle\QuerySerializer;
+
+class Rfc3986Serializer implements QuerySerializerInterface
+{
+    /**
+     * @var bool
+     */
+    private $removeNumericIndices;
+
+    /**
+     * @param bool $removeNumericIndices
+     */
+    public function __construct($removeNumericIndices = false)
+    {
+        $this->removeNumericIndices = $removeNumericIndices;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function aggregate(array $queryParams)
+    {
+        $queryString = http_build_query($queryParams, '', '&', PHP_QUERY_RFC3986);
+
+        if ($this->removeNumericIndices) {
+            $queryString = preg_replace('/%5B[0-9]+%5D/simU', '%5B%5D', $queryString);
+        }
+
+        return $queryString;
+    }
+}

vendor/guzzlehttp/guzzle-services/src/RequestLocation/AbstractLocation.php

@@ -0,0 +1,101 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\RequestLocation;
+
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Guzzle\Operation;
+use GuzzleHttp\Command\Guzzle\Parameter;
+use Psr\Http\Message\RequestInterface;
+
+abstract class AbstractLocation implements RequestLocationInterface
+{
+    /** @var string */
+    protected $locationName;
+
+    /**
+     * Set the name of the location
+     *
+     * @param $locationName
+     */
+    public function __construct($locationName)
+    {
+        $this->locationName = $locationName;
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Parameter $param
+     * @return RequestInterface
+     */
+    public function visit(
+        CommandInterface $command,
+        RequestInterface $request,
+        Parameter $param
+    ) {
+        return $request;
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Operation $operation
+     * @return RequestInterface
+     */
+    public function after(
+        CommandInterface $command,
+        RequestInterface $request,
+        Operation $operation
+    ) {
+        return $request;
+    }
+
+    /**
+     * Prepare (filter and set desired name for request item) the value for
+     * request.
+     *
+     * @param mixed     $value
+     * @param Parameter $param
+     *
+     * @return array|mixed
+     */
+    protected function prepareValue($value, Parameter $param)
+    {
+        return is_array($value)
+            ? $this->resolveRecursively($value, $param)
+            : $param->filter($value);
+    }
+
+    /**
+     * Recursively prepare and filter nested values.
+     *
+     * @param array     $value Value to map
+     * @param Parameter $param Parameter related to the current key.
+     *
+     * @return array Returns the mapped array
+     */
+    protected function resolveRecursively(array $value, Parameter $param)
+    {
+        foreach ($value as $name => &$v) {
+            switch ($param->getType()) {
+                case 'object':
+                    if ($subParam = $param->getProperty($name)) {
+                        $key = $subParam->getWireName();
+                        $value[$key] = $this->prepareValue($v, $subParam);
+                        if ($name != $key) {
+                            unset($value[$name]);
+                        }
+                    } elseif ($param->getAdditionalProperties() instanceof Parameter) {
+                        $v = $this->prepareValue($v, $param->getAdditionalProperties());
+                    }
+                    break;
+                case 'array':
+                    if ($items = $param->getItems()) {
+                        $v = $this->prepareValue($v, $items);
+                    }
+                    break;
+            }
+        }
+
+        return $param->filter($value);
+    }
+}

vendor/guzzlehttp/guzzle-services/src/RequestLocation/BodyLocation.php

@@ -0,0 +1,49 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\RequestLocation;
+
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Psr7;
+use Psr\Http\Message\MessageInterface;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Adds a body to a request
+ */
+class BodyLocation extends AbstractLocation
+{
+
+    /**
+     * Set the name of the location
+     *
+     * @param string $locationName
+     */
+    public function __construct($locationName = 'body')
+    {
+        parent::__construct($locationName);
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Parameter        $param
+     *
+     * @return MessageInterface
+     */
+    public function visit(
+        CommandInterface $command,
+        RequestInterface $request,
+        Parameter $param
+    ) {
+        $oldValue = $request->getBody()->getContents();
+
+        $value = $command[$param->getName()];
+        $value = $param->getName() . '=' . $param->filter($value);
+
+        if ($oldValue !== '') {
+            $value = $oldValue . '&' . $value;
+        }
+
+        return $request->withBody(Psr7\Utils::streamFor($value));
+    }
+}

vendor/guzzlehttp/guzzle-services/src/RequestLocation/FormParamLocation.php

@@ -0,0 +1,83 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\RequestLocation;
+
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Guzzle\Operation;
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Psr7;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Add form_params to a request
+ */
+class FormParamLocation extends AbstractLocation
+{
+    /** @var string $contentType */
+    protected $contentType = 'application/x-www-form-urlencoded; charset=utf-8';
+
+    /** @var array $formParamsData */
+    protected $formParamsData = [];
+
+    /**
+     * Set the name of the location
+     *
+     * @param string $locationName
+     */
+    public function __construct($locationName = 'formParam')
+    {
+        parent::__construct($locationName);
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Parameter        $param
+     *
+     * @return RequestInterface
+     */
+    public function visit(
+        CommandInterface $command,
+        RequestInterface $request,
+        Parameter $param
+    ) {
+        $this->formParamsData['form_params'][$param->getWireName()] = $this->prepareValue(
+            $command[$param->getName()],
+            $param
+        );
+
+        return $request;
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Operation        $operation
+     *
+     * @return RequestInterface
+     */
+    public function after(
+        CommandInterface $command,
+        RequestInterface $request,
+        Operation $operation
+    ) {
+        $data = $this->formParamsData;
+        $this->formParamsData = [];
+        $modify = [];
+
+        // Add additional parameters to the form_params array
+        $additional = $operation->getAdditionalParameters();
+        if ($additional && $additional->getLocation() == $this->locationName) {
+            foreach ($command->toArray() as $key => $value) {
+                if (!$operation->hasParam($key)) {
+                    $data['form_params'][$key] = $this->prepareValue($value, $additional);
+                }
+            }
+        }
+
+        $body = http_build_query($data['form_params'], '', '&');
+        $modify['body'] = Psr7\Utils::streamFor($body);
+        $modify['set_headers']['Content-Type'] = $this->contentType;
+
+        return Psr7\Utils::modifyRequest($request, $modify);
+    }
+}

vendor/guzzlehttp/guzzle-services/src/RequestLocation/HeaderLocation.php

@@ -0,0 +1,67 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\RequestLocation;
+
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Guzzle\Operation;
+use GuzzleHttp\Command\Guzzle\Parameter;
+use Psr\Http\Message\MessageInterface;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Request header location
+ */
+class HeaderLocation extends AbstractLocation
+{
+
+    /**
+     * Set the name of the location
+     *
+     * @param string $locationName
+     */
+    public function __construct($locationName = 'header')
+    {
+        parent::__construct($locationName);
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Parameter        $param
+     *
+     * @return MessageInterface
+     */
+    public function visit(
+        CommandInterface $command,
+        RequestInterface $request,
+        Parameter $param
+    ) {
+        $value = $command[$param->getName()];
+
+        return $request->withHeader($param->getWireName(), $param->filter($value));
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Operation        $operation
+     *
+     * @return RequestInterface
+     */
+    public function after(
+        CommandInterface $command,
+        RequestInterface $request,
+        Operation $operation
+    ) {
+        /** @var Parameter $additional */
+        $additional = $operation->getAdditionalParameters();
+        if ($additional && ($additional->getLocation() === $this->locationName)) {
+            foreach ($command->toArray() as $key => $value) {
+                if (!$operation->hasParam($key)) {
+                    $request = $request->withHeader($key, $additional->filter($value));
+                }
+            }
+        }
+
+        return $request;
+    }
+}

vendor/guzzlehttp/guzzle-services/src/RequestLocation/JsonLocation.php

@@ -0,0 +1,86 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\RequestLocation;
+
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Guzzle\Operation;
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Psr7;
+use GuzzleHttp\Utils;
+use Psr\Http\Message\MessageInterface;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Creates a JSON document
+ */
+class JsonLocation extends AbstractLocation
+{
+    /** @var string Whether or not to add a Content-Type header when JSON is found */
+    private $jsonContentType;
+
+    /** @var array */
+    private $jsonData;
+
+    /**
+     * @param string $locationName Name of the location
+     * @param string $contentType  Content-Type header to add to the request if
+     *     JSON is added to the body. Pass an empty string to omit.
+     */
+    public function __construct($locationName = 'json', $contentType = 'application/json')
+    {
+        parent::__construct($locationName);
+        $this->jsonContentType = $contentType;
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Parameter        $param
+     *
+     * @return RequestInterface
+     */
+    public function visit(
+        CommandInterface $command,
+        RequestInterface $request,
+        Parameter $param
+    ) {
+        $this->jsonData[$param->getWireName()] = $this->prepareValue(
+            $command[$param->getName()],
+            $param
+        );
+
+        return $request->withBody(Psr7\Utils::streamFor(Utils::jsonEncode($this->jsonData)));
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Operation        $operation
+     *
+     * @return MessageInterface
+     */
+    public function after(
+        CommandInterface $command,
+        RequestInterface $request,
+        Operation $operation
+    ) {
+        $data = $this->jsonData;
+        $this->jsonData = [];
+
+        // Add additional parameters to the JSON document
+        $additional = $operation->getAdditionalParameters();
+        if ($additional && ($additional->getLocation() === $this->locationName)) {
+            foreach ($command->toArray() as $key => $value) {
+                if (!$operation->hasParam($key)) {
+                    $data[$key] = $this->prepareValue($value, $additional);
+                }
+            }
+        }
+
+        // Don't overwrite the Content-Type if one is set
+        if ($this->jsonContentType && !$request->hasHeader('Content-Type')) {
+            $request = $request->withHeader('Content-Type', $this->jsonContentType);
+        }
+
+        return $request->withBody(Psr7\Utils::streamFor(Utils::jsonEncode($data)));
+    }
+}

vendor/guzzlehttp/guzzle-services/src/RequestLocation/MultiPartLocation.php

@@ -0,0 +1,76 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\RequestLocation;
+
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Guzzle\Operation;
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Psr7;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Adds POST files to a request
+ */
+class MultiPartLocation extends AbstractLocation
+{
+    /** @var string $contentType */
+    protected $contentType = 'multipart/form-data; boundary=';
+
+    /** @var array $formParamsData */
+    protected $multipartData = [];
+
+    /**
+     * Set the name of the location
+     *
+     * @param string $locationName
+     */
+    public function __construct($locationName = 'multipart')
+    {
+        parent::__construct($locationName);
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Parameter $param
+     * @return RequestInterface
+     */
+    public function visit(
+        CommandInterface $command,
+        RequestInterface $request,
+        Parameter $param
+    ) {
+        $this->multipartData[] = [
+            'name' => $param->getWireName(),
+            'contents' => $this->prepareValue($command[$param->getName()], $param)
+        ];
+
+        return $request;
+    }
+
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Operation $operation
+     * @return RequestInterface
+     */
+    public function after(
+        CommandInterface $command,
+        RequestInterface $request,
+        Operation $operation
+    ) {
+        $data = $this->multipartData;
+        $this->multipartData = [];
+        $modify = [];
+
+        $body = new Psr7\MultipartStream($data);
+        $modify['body'] = Psr7\Utils::streamFor($body);
+        $request = Psr7\Utils::modifyRequest($request, $modify);
+        if ($request->getBody() instanceof Psr7\MultipartStream) {
+            // Use a multipart/form-data POST if a Content-Type is not set.
+            $request->withHeader('Content-Type', $this->contentType . $request->getBody()->getBoundary());
+        }
+
+        return $request;
+    }
+}

vendor/guzzlehttp/guzzle-services/src/RequestLocation/QueryLocation.php

@@ -0,0 +1,92 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\RequestLocation;
+
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Guzzle\Operation;
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Command\Guzzle\QuerySerializer\QuerySerializerInterface;
+use GuzzleHttp\Command\Guzzle\QuerySerializer\Rfc3986Serializer;
+use GuzzleHttp\Psr7;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Adds query string values to requests
+ */
+class QueryLocation extends AbstractLocation
+{
+    /**
+     * @var QuerySerializerInterface
+     */
+    private $querySerializer;
+
+    /**
+     * Set the name of the location
+     *
+     * @param string                        $locationName
+     * @param QuerySerializerInterface|null $querySerializer
+     */
+    public function __construct($locationName = 'query', QuerySerializerInterface $querySerializer = null)
+    {
+        parent::__construct($locationName);
+
+        $this->querySerializer = $querySerializer ?: new Rfc3986Serializer();
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Parameter        $param
+     *
+     * @return RequestInterface
+     */
+    public function visit(
+        CommandInterface $command,
+        RequestInterface $request,
+        Parameter $param
+    ) {
+        $uri = $request->getUri();
+        $query = Psr7\Query::parse($uri->getQuery());
+
+        $query[$param->getWireName()] = $this->prepareValue(
+            $command[$param->getName()],
+            $param
+        );
+
+        $uri = $uri->withQuery($this->querySerializer->aggregate($query));
+
+        return $request->withUri($uri);
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Operation        $operation
+     *
+     * @return RequestInterface
+     */
+    public function after(
+        CommandInterface $command,
+        RequestInterface $request,
+        Operation $operation
+    ) {
+        $additional = $operation->getAdditionalParameters();
+        if ($additional && $additional->getLocation() == $this->locationName) {
+            foreach ($command->toArray() as $key => $value) {
+                if (!$operation->hasParam($key)) {
+                    $uri = $request->getUri();
+                    $query = Psr7\Query::parse($uri->getQuery());
+
+                    $query[$key] = $this->prepareValue(
+                        $value,
+                        $additional
+                    );
+
+                    $uri = $uri->withQuery($this->querySerializer->aggregate($query));
+                    $request = $request->withUri($uri);
+                }
+            }
+        }
+
+        return $request;
+    }
+}

vendor/guzzlehttp/guzzle-services/src/RequestLocation/RequestLocationInterface.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace GuzzleHttp\Command\Guzzle\RequestLocation;
+
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Guzzle\Operation;
+use GuzzleHttp\Command\Guzzle\Parameter;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Handles locations specified in a service description
+ */
+interface RequestLocationInterface
+{
+    /**
+     * Visits a location for each top-level parameter
+     *
+     * @param CommandInterface $command Command being prepared
+     * @param RequestInterface $request Request being modified
+     * @param Parameter        $param   Parameter being visited
+     *
+     * @return RequestInterface Modified request
+     */
+    public function visit(
+        CommandInterface $command,
+        RequestInterface $request,
+        Parameter $param
+    );
+
+    /**
+     * Called when all of the parameters of a command have been visited.
+     *
+     * @param CommandInterface $command   Command being prepared
+     * @param RequestInterface $request   Request being modified
+     * @param Operation        $operation Operation being serialized
+     *
+     * @return RequestInterface Modified request
+     */
+    public function after(
+        CommandInterface $command,
+        RequestInterface $request,
+        Operation $operation
+    );
+}

vendor/guzzlehttp/guzzle-services/src/RequestLocation/XmlLocation.php

@@ -0,0 +1,328 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\RequestLocation;
+
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Guzzle\Operation;
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Psr7;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Creates an XML document
+ */
+class XmlLocation extends AbstractLocation
+{
+    /** @var \XMLWriter XML writer resource */
+    private $writer;
+
+    /** @var string Content-Type header added when XML is found */
+    private $contentType;
+
+    /** @var Parameter[] Buffered elements to write */
+    private $buffered = [];
+
+    /**
+     * @param string $locationName Name of the location
+     * @param string $contentType  Set to a non-empty string to add a
+     *     Content-Type header to a request if any XML content is added to the
+     *     body. Pass an empty string to disable the addition of the header.
+     */
+    public function __construct($locationName = 'xml', $contentType = 'application/xml')
+    {
+        parent::__construct($locationName);
+        $this->contentType = $contentType;
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Parameter        $param
+     *
+     * @return RequestInterface
+     */
+    public function visit(
+        CommandInterface $command,
+        RequestInterface $request,
+        Parameter $param
+    ) {
+        // Buffer and order the parameters to visit based on if they are
+        // top-level attributes or child nodes.
+        // @link https://github.com/guzzle/guzzle/pull/494
+        if ($param->getData('xmlAttribute')) {
+            array_unshift($this->buffered, $param);
+        } else {
+            $this->buffered[] = $param;
+        }
+
+        return $request;
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param RequestInterface $request
+     * @param Operation        $operation
+     *
+     * @return RequestInterface
+     */
+    public function after(
+        CommandInterface $command,
+        RequestInterface $request,
+        Operation $operation
+    ) {
+        foreach ($this->buffered as $param) {
+            $this->visitWithValue(
+                $command[$param->getName()],
+                $param,
+                $operation
+            );
+        }
+
+        $this->buffered = [];
+
+        $additional = $operation->getAdditionalParameters();
+        if ($additional && $additional->getLocation() == $this->locationName) {
+            foreach ($command->toArray() as $key => $value) {
+                if (!$operation->hasParam($key)) {
+                    $additional->setName($key);
+                    $this->visitWithValue($value, $additional, $operation);
+                }
+            }
+            $additional->setName(null);
+        }
+
+        // If data was found that needs to be serialized, then do so
+        $xml = '';
+        if ($this->writer) {
+            $xml = $this->finishDocument($this->writer);
+        } elseif ($operation->getData('xmlAllowEmpty')) {
+            // Check if XML should always be sent for the command
+            $writer = $this->createRootElement($operation);
+            $xml = $this->finishDocument($writer);
+        }
+
+        if ($xml !== '') {
+            $request = $request->withBody(Psr7\Utils::streamFor($xml));
+            // Don't overwrite the Content-Type if one is set
+            if ($this->contentType && !$request->hasHeader('Content-Type')) {
+                $request = $request->withHeader('Content-Type', $this->contentType);
+            }
+        }
+
+        $this->writer = null;
+
+        return $request;
+    }
+
+    /**
+     * Create the root XML element to use with a request
+     *
+     * @param Operation $operation Operation object
+     *
+     * @return \XMLWriter
+     */
+    protected function createRootElement(Operation $operation)
+    {
+        static $defaultRoot = ['name' => 'Request'];
+        // If no root element was specified, then just wrap the XML in 'Request'
+        $root = $operation->getData('xmlRoot') ?: $defaultRoot;
+        // Allow the XML declaration to be customized with xmlEncoding
+        $encoding = $operation->getData('xmlEncoding');
+        $writer = $this->startDocument($encoding);
+        $writer->startElement($root['name']);
+
+        // Create the wrapping element with no namespaces if no namespaces were present
+        if (!empty($root['namespaces'])) {
+            // Create the wrapping element with an array of one or more namespaces
+            foreach ((array) $root['namespaces'] as $prefix => $uri) {
+                $nsLabel = 'xmlns';
+                if (!is_numeric($prefix)) {
+                    $nsLabel .= ':'.$prefix;
+                }
+                $writer->writeAttribute($nsLabel, $uri);
+            }
+        }
+
+        return $writer;
+    }
+
+    /**
+     * Recursively build the XML body
+     *
+     * @param \XMLWriter $writer XML to modify
+     * @param Parameter  $param     API Parameter
+     * @param mixed      $value     Value to add
+     */
+    protected function addXml(\XMLWriter $writer, Parameter $param, $value)
+    {
+        $value = $param->filter($value);
+        $type = $param->getType();
+        $name = $param->getWireName();
+        $prefix = null;
+        $namespace = $param->getData('xmlNamespace');
+        if (false !== strpos($name, ':')) {
+            list($prefix, $name) = explode(':', $name, 2);
+        }
+
+        if ($type == 'object' || $type == 'array') {
+            if (!$param->getData('xmlFlattened')) {
+                if ($namespace) {
+                    $writer->startElementNS(null, $name, $namespace);
+                } else {
+                    $writer->startElement($name);
+                }
+            }
+            if ($param->getType() == 'array') {
+                $this->addXmlArray($writer, $param, $value);
+            } elseif ($param->getType() == 'object') {
+                $this->addXmlObject($writer, $param, $value);
+            }
+            if (!$param->getData('xmlFlattened')) {
+                $writer->endElement();
+            }
+            return;
+        }
+        if ($param->getData('xmlAttribute')) {
+            $this->writeAttribute($writer, $prefix, $name, $namespace, $value);
+        } else {
+            $this->writeElement($writer, $prefix, $name, $namespace, $value);
+        }
+    }
+
+    /**
+     * Write an attribute with namespace if used
+     *
+     * @param  \XMLWriter $writer XMLWriter instance
+     * @param  string     $prefix    Namespace prefix if any
+     * @param  string     $name      Attribute name
+     * @param  string     $namespace The uri of the namespace
+     * @param  string     $value     The attribute content
+     */
+    protected function writeAttribute($writer, $prefix, $name, $namespace, $value)
+    {
+        if ($namespace) {
+            $writer->writeAttributeNS($prefix, $name, $namespace, $value);
+        } else {
+            $writer->writeAttribute($name, $value);
+        }
+    }
+
+    /**
+     * Write an element with namespace if used
+     *
+     * @param  \XMLWriter $writer XML writer resource
+     * @param  string     $prefix    Namespace prefix if any
+     * @param  string     $name      Element name
+     * @param  string     $namespace The uri of the namespace
+     * @param  string     $value     The element content
+     */
+    protected function writeElement(\XMLWriter $writer, $prefix, $name, $namespace, $value)
+    {
+        if ($namespace) {
+            $writer->startElementNS($prefix, $name, $namespace);
+        } else {
+            $writer->startElement($name);
+        }
+        if (strpbrk($value, '<>&')) {
+            $writer->writeCData($value);
+        } else {
+            $writer->writeRaw($value);
+        }
+        $writer->endElement();
+    }
+
+    /**
+     * Create a new xml writer and start a document
+     *
+     * @param  string $encoding document encoding
+     *
+     * @return \XMLWriter the writer resource
+     * @throws \RuntimeException if the document cannot be started
+     */
+    protected function startDocument($encoding)
+    {
+        $this->writer = new \XMLWriter();
+        if (!$this->writer->openMemory()) {
+            throw new \RuntimeException('Unable to open XML document in memory');
+        }
+        if (!$this->writer->startDocument('1.0', $encoding)) {
+            throw new \RuntimeException('Unable to start XML document');
+        }
+
+        return $this->writer;
+    }
+
+    /**
+     * End the document and return the output
+     *
+     * @param \XMLWriter $writer
+     *
+     * @return string the writer resource
+     */
+    protected function finishDocument($writer)
+    {
+        $writer->endDocument();
+
+        return $writer->outputMemory();
+    }
+
+    /**
+     * Add an array to the XML
+     *
+     * @param \XMLWriter $writer
+     * @param Parameter $param
+     * @param $value
+     */
+    protected function addXmlArray(\XMLWriter $writer, Parameter $param, &$value)
+    {
+        if ($items = $param->getItems()) {
+            foreach ($value as $v) {
+                $this->addXml($writer, $items, $v);
+            }
+        }
+    }
+
+    /**
+     * Add an object to the XML
+     *
+     * @param \XMLWriter $writer
+     * @param Parameter $param
+     * @param $value
+     */
+    protected function addXmlObject(\XMLWriter $writer, Parameter $param, &$value)
+    {
+        $noAttributes = [];
+
+        // add values which have attributes
+        foreach ($value as $name => $v) {
+            if ($property = $param->getProperty($name)) {
+                if ($property->getData('xmlAttribute')) {
+                    $this->addXml($writer, $property, $v);
+                } else {
+                    $noAttributes[] = ['value' => $v, 'property' => $property];
+                }
+            }
+        }
+
+        // now add values with no attributes
+        foreach ($noAttributes as $element) {
+            $this->addXml($writer, $element['property'], $element['value']);
+        }
+    }
+
+    /**
+     * @param $value
+     * @param Parameter $param
+     * @param Operation $operation
+     */
+    private function visitWithValue(
+        $value,
+        Parameter $param,
+        Operation $operation
+    ) {
+        if (!$this->writer) {
+            $this->createRootElement($operation);
+        }
+
+        $this->addXml($this->writer, $param, $value);
+    }
+}

vendor/guzzlehttp/guzzle-services/src/ResponseLocation/AbstractLocation.php

@@ -0,0 +1,69 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\ResponseLocation;
+
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Command\ResultInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Class AbstractLocation
+ *
+ * @package GuzzleHttp\Command\Guzzle\ResponseLocation
+ */
+abstract class AbstractLocation implements ResponseLocationInterface
+{
+    /** @var string $locationName */
+    protected $locationName;
+
+    /**
+     * Set the name of the location
+     *
+     * @param $locationName
+     */
+    public function __construct($locationName)
+    {
+        $this->locationName = $locationName;
+    }
+
+    /**
+     * @param ResultInterface $result
+     * @param ResponseInterface $response
+     * @param Parameter $model
+     * @return ResultInterface
+     */
+    public function before(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $model
+    ) {
+        return $result;
+    }
+
+    /**
+     * @param ResultInterface $result
+     * @param ResponseInterface $response
+     * @param Parameter $model
+     * @return ResultInterface
+     */
+    public function after(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $model
+    ) {
+        return $result;
+    }
+
+    /**
+     * @param ResultInterface $result
+     * @param ResponseInterface $response
+     * @param Parameter $param
+     * @return ResultInterface
+     */
+    public function visit(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $param
+    ) {
+        return $result;
+    }
+}

vendor/guzzlehttp/guzzle-services/src/ResponseLocation/BodyLocation.php

@@ -0,0 +1,39 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\ResponseLocation;
+
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Command\ResultInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Extracts the body of a response into a result field
+ */
+class BodyLocation extends AbstractLocation
+{
+
+    /**
+     * Set the name of the location
+     *
+     * @param string $locationName
+     */
+    public function __construct($locationName = 'body')
+    {
+        parent::__construct($locationName);
+    }
+
+    /**
+     * @param ResultInterface $result
+     * @param ResponseInterface $response
+     * @param Parameter $param
+     * @return ResultInterface
+     */
+    public function visit(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $param
+    ) {
+        $result[$param->getName()] = $param->filter($response->getBody());
+
+        return $result;
+    }
+}

vendor/guzzlehttp/guzzle-services/src/ResponseLocation/HeaderLocation.php

@@ -0,0 +1,47 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\ResponseLocation;
+
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Command\ResultInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Extracts headers from the response into a result fields
+ */
+class HeaderLocation extends AbstractLocation
+{
+
+    /**
+     * Set the name of the location
+     *
+     * @param string $locationName
+     */
+    public function __construct($locationName = 'header')
+    {
+        parent::__construct($locationName);
+    }
+
+    /**
+     * @param ResultInterface   $result
+     * @param ResponseInterface $response
+     * @param Parameter         $param
+     *
+     * @return ResultInterface
+     */
+    public function visit(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $param
+    ) {
+        // Retrieving a single header by name
+        $name = $param->getName();
+        if ($header = $response->getHeader($param->getWireName())) {
+            if (is_array($header)) {
+                $header = array_shift($header);
+            }
+            $result[$name] = $param->filter($header);
+        }
+
+        return $result;
+    }
+}

vendor/guzzlehttp/guzzle-services/src/ResponseLocation/JsonLocation.php

@@ -0,0 +1,176 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\ResponseLocation;
+
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Command\Result;
+use GuzzleHttp\Command\ResultInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Extracts elements from a JSON document.
+ */
+class JsonLocation extends AbstractLocation
+{
+    /** @var array The JSON document being visited */
+    private $json = [];
+
+    /**
+     * Set the name of the location
+     *
+     * @param string $locationName
+     */
+    public function __construct($locationName = 'json')
+    {
+        parent::__construct($locationName);
+    }
+
+    /**
+     * @param \GuzzleHttp\Command\ResultInterface  $result
+     * @param \Psr\Http\Message\ResponseInterface  $response
+     * @param \GuzzleHttp\Command\Guzzle\Parameter $model
+     *
+     * @return \GuzzleHttp\Command\ResultInterface
+     */
+    public function before(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $model
+    ) {
+        $body = (string) $response->getBody();
+        $body = $body ?: "{}";
+        $this->json = \GuzzleHttp\json_decode($body, true);
+        // relocate named arrays, so that they have the same structure as
+        //  arrays nested in objects and visit can work on them in the same way
+        if ($model->getType() === 'array' && ($name = $model->getName())) {
+            $this->json = [$name => $this->json];
+        }
+
+        return $result;
+    }
+
+    /**
+     * @param ResultInterface $result
+     * @param ResponseInterface $response
+     * @param Parameter $model
+     * @return ResultInterface
+     */
+    public function after(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $model
+    ) {
+        // Handle additional, undefined properties
+        $additional = $model->getAdditionalProperties();
+        if (!($additional instanceof Parameter)) {
+            return $result;
+        }
+
+        // Use the model location as the default if one is not set on additional
+        $addLocation = $additional->getLocation() ?: $model->getLocation();
+        if ($addLocation == $this->locationName) {
+            foreach ($this->json as $prop => $val) {
+                if (!isset($result[$prop])) {
+                    // Only recurse if there is a type specified
+                    $result[$prop] = $additional->getType()
+                        ? $this->recurse($additional, $val)
+                        : $val;
+                }
+            }
+        }
+
+        $this->json = [];
+
+        return $result;
+    }
+
+    /**
+     * @param ResultInterface $result
+     * @param ResponseInterface $response
+     * @param Parameter $param
+     * @return Result|ResultInterface
+     */
+    public function visit(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $param
+    ) {
+        $name = $param->getName();
+        $key = $param->getWireName();
+
+        // Check if the result should be treated as a list
+        if ($param->getType() == 'array') {
+            // Treat as javascript array
+            if ($name) {
+                // name provided, store it under a key in the array
+                $subArray = isset($this->json[$key]) ? $this->json[$key] : null;
+                $result[$name] = $this->recurse($param, $subArray);
+            } else {
+                // top-level `array` or an empty name
+                $result = new Result(array_merge(
+                    $result->toArray(),
+                    $this->recurse($param, $this->json)
+                ));
+            }
+        } elseif (isset($this->json[$key])) {
+            $result[$name] = $this->recurse($param, $this->json[$key]);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Recursively process a parameter while applying filters
+     *
+     * @param Parameter $param API parameter being validated
+     * @param mixed     $value Value to process.
+     * @return mixed|null
+     */
+    private function recurse(Parameter $param, $value)
+    {
+        if (!is_array($value)) {
+            return $param->filter($value);
+        }
+
+        $result = [];
+        $type = $param->getType();
+
+        if ($type == 'array') {
+            $items = $param->getItems();
+            foreach ($value as $val) {
+                $result[] = $this->recurse($items, $val);
+            }
+        } elseif ($type == 'object' && !isset($value[0])) {
+            // On the above line, we ensure that the array is associative and
+            // not numerically indexed
+            if ($properties = $param->getProperties()) {
+                foreach ($properties as $property) {
+                    $key = $property->getWireName();
+                    if (array_key_exists($key, $value)) {
+                        $result[$property->getName()] = $this->recurse(
+                            $property,
+                            $value[$key]
+                        );
+                        // Remove from the value so that AP can later be handled
+                        unset($value[$key]);
+                    }
+                }
+            }
+            // Only check additional properties if everything wasn't already
+            // handled
+            if ($value) {
+                $additional = $param->getAdditionalProperties();
+                if ($additional === null || $additional === true) {
+                    // Merge the JSON under the resulting array
+                    $result += $value;
+                } elseif ($additional instanceof Parameter) {
+                    // Process all child elements according to the given schema
+                    foreach ($value as $prop => $val) {
+                        $result[$prop] = $this->recurse($additional, $val);
+                    }
+                }
+            }
+        }
+
+        return $param->filter($result);
+    }
+}

vendor/guzzlehttp/guzzle-services/src/ResponseLocation/ReasonPhraseLocation.php

@@ -0,0 +1,41 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\ResponseLocation;
+
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Command\ResultInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Extracts the reason phrase of a response into a result field
+ */
+class ReasonPhraseLocation extends AbstractLocation
+{
+
+    /**
+     * Set the name of the location
+     *
+     * @param string $locationName
+     */
+    public function __construct($locationName = 'reasonPhrase')
+    {
+        parent::__construct($locationName);
+    }
+
+    /**
+     * @param ResultInterface $result
+     * @param ResponseInterface $response
+     * @param Parameter $param
+     * @return ResultInterface
+     */
+    public function visit(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $param
+    ) {
+        $result[$param->getName()] = $param->filter(
+            $response->getReasonPhrase()
+        );
+
+        return $result;
+    }
+}

vendor/guzzlehttp/guzzle-services/src/ResponseLocation/ResponseLocationInterface.php

@@ -0,0 +1,61 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\ResponseLocation;
+
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Command\ResultInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Location visitor used to parse values out of a response into an associative
+ * array
+ */
+interface ResponseLocationInterface
+{
+    /**
+     * Called before visiting all parameters. This can be used for seeding the
+     * result of a command with default data (e.g. populating with JSON data in
+     * the response then adding to the parsed data).
+     *
+     * @param ResultInterface   $result   Result being created
+     * @param ResponseInterface $response Response being visited
+     * @param Parameter         $model    Response model
+     *
+     * @return ResultInterface Modified result
+     */
+    public function before(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $model
+    );
+
+    /**
+     * Called after visiting all parameters
+     *
+     * @param ResultInterface   $result   Result being created
+     * @param ResponseInterface $response Response being visited
+     * @param Parameter         $model    Response model
+     *
+     * @return ResultInterface Modified result
+     */
+    public function after(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $model
+    );
+
+    /**
+     * Called once for each parameter being visited that matches the location
+     * type.
+     *
+     * @param ResultInterface   $result   Result being created
+     * @param ResponseInterface $response Response being visited
+     * @param Parameter         $param    Parameter being visited
+     *
+     * @return ResultInterface Modified result
+     */
+    public function visit(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $param
+    );
+}

vendor/guzzlehttp/guzzle-services/src/ResponseLocation/StatusCodeLocation.php

@@ -0,0 +1,39 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\ResponseLocation;
+
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Command\ResultInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Extracts the status code of a response into a result field
+ */
+class StatusCodeLocation extends AbstractLocation
+{
+
+    /**
+     * Set the name of the location
+     *
+     * @param string $locationName
+     */
+    public function __construct($locationName = 'statusCode')
+    {
+        parent::__construct($locationName);
+    }
+
+    /**
+     * @param ResultInterface $result
+     * @param ResponseInterface $response
+     * @param Parameter $param
+     * @return ResultInterface
+     */
+    public function visit(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $param
+    ) {
+        $result[$param->getName()] = $param->filter($response->getStatusCode());
+
+        return $result;
+    }
+}

vendor/guzzlehttp/guzzle-services/src/ResponseLocation/XmlLocation.php

@@ -0,0 +1,311 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle\ResponseLocation;
+
+use GuzzleHttp\Command\Guzzle\Parameter;
+use GuzzleHttp\Command\Result;
+use GuzzleHttp\Command\ResultInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Extracts elements from an XML document
+ */
+class XmlLocation extends AbstractLocation
+{
+    /** @var \SimpleXMLElement XML document being visited */
+    private $xml;
+
+    /**
+     * Set the name of the location
+     *
+     * @param string $locationName
+     */
+    public function __construct($locationName = 'xml')
+    {
+        parent::__construct($locationName);
+    }
+
+    /**
+     * @param ResultInterface $result
+     * @param ResponseInterface $response
+     * @param Parameter $model
+     * @return ResultInterface
+     */
+    public function before(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $model
+    ) {
+        $this->xml = simplexml_load_string((string) $response->getBody());
+
+        return $result;
+    }
+
+    /**
+     * @param ResultInterface $result
+     * @param ResponseInterface $response
+     * @param Parameter $model
+     * @return Result|ResultInterface
+     */
+    public function after(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $model
+    ) {
+        // Handle additional, undefined properties
+        $additional = $model->getAdditionalProperties();
+        if ($additional instanceof Parameter &&
+            $additional->getLocation() == $this->locationName
+        ) {
+            $result = new Result(array_merge(
+                $result->toArray(),
+                self::xmlToArray($this->xml)
+            ));
+        }
+
+        $this->xml = null;
+
+        return $result;
+    }
+
+    /**
+     * @param ResultInterface $result
+     * @param ResponseInterface $response
+     * @param Parameter $param
+     * @return ResultInterface
+     */
+    public function visit(
+        ResultInterface $result,
+        ResponseInterface $response,
+        Parameter $param
+    ) {
+        $sentAs = $param->getWireName();
+        $ns = null;
+        if (strstr($sentAs, ':')) {
+            list($ns, $sentAs) = explode(':', $sentAs);
+        }
+
+        // Process the primary property
+        if (count($this->xml->children($ns, true)->{$sentAs})) {
+            $result[$param->getName()] = $this->recursiveProcess(
+                $param,
+                $this->xml->children($ns, true)->{$sentAs}
+            );
+        }
+
+        return $result;
+    }
+
+    /**
+     * Recursively process a parameter while applying filters
+     *
+     * @param Parameter         $param API parameter being processed
+     * @param \SimpleXMLElement $node  Node being processed
+     * @return array
+     */
+    private function recursiveProcess(
+        Parameter $param,
+        \SimpleXMLElement $node
+    ) {
+        $result = [];
+        $type = $param->getType();
+
+        if ($type == 'object') {
+            $result = $this->processObject($param, $node);
+        } elseif ($type == 'array') {
+            $result = $this->processArray($param, $node);
+        } else {
+            // We are probably handling a flat data node (i.e. string or
+            // integer), so let's check if it's childless, which indicates a
+            // node containing plain text.
+            if ($node->children()->count() == 0) {
+                // Retrieve text from node
+                $result = (string) $node;
+            }
+        }
+
+        // Filter out the value
+        if (isset($result)) {
+            $result = $param->filter($result);
+        }
+
+        return $result;
+    }
+
+    /**
+     * @param Parameter $param
+     * @param \SimpleXMLElement $node
+     * @return array
+     */
+    private function processArray(Parameter $param, \SimpleXMLElement $node)
+    {
+        // Cast to an array if the value was a string, but should be an array
+        $items = $param->getItems();
+        $sentAs = $items->getWireName();
+        $result = [];
+        $ns = null;
+
+        if (strstr($sentAs, ':')) {
+            // Get namespace from the wire name
+            list($ns, $sentAs) = explode(':', $sentAs);
+        } else {
+            // Get namespace from data
+            $ns = $items->getData('xmlNs');
+        }
+
+        if ($sentAs === null) {
+            // A general collection of nodes
+            foreach ($node as $child) {
+                $result[] = $this->recursiveProcess($items, $child);
+            }
+        } else {
+            // A collection of named, repeating nodes
+            // (i.e. <collection><foo></foo><foo></foo></collection>)
+            $children = $node->children($ns, true)->{$sentAs};
+            foreach ($children as $child) {
+                $result[] = $this->recursiveProcess($items, $child);
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Process an object
+     *
+     * @param Parameter         $param API parameter being parsed
+     * @param \SimpleXMLElement $node  Value to process
+     * @return array
+     */
+    private function processObject(Parameter $param, \SimpleXMLElement $node)
+    {
+        $result = $knownProps = $knownAttributes = [];
+
+        // Handle known properties
+        if ($properties = $param->getProperties()) {
+            foreach ($properties as $property) {
+                $name = $property->getName();
+                $sentAs = $property->getWireName();
+                $knownProps[$sentAs] = 1;
+                if (strpos($sentAs, ':')) {
+                    list($ns, $sentAs) = explode(':', $sentAs);
+                } else {
+                    $ns = $property->getData('xmlNs');
+                }
+
+                if ($property->getData('xmlAttribute')) {
+                    // Handle XML attributes
+                    $result[$name] = (string) $node->attributes($ns, true)->{$sentAs};
+                    $knownAttributes[$sentAs] = 1;
+                } elseif (count($node->children($ns, true)->{$sentAs})) {
+                    // Found a child node matching wire name
+                    $childNode = $node->children($ns, true)->{$sentAs};
+                    $result[$name] = $this->recursiveProcess(
+                        $property,
+                        $childNode
+                    );
+                }
+            }
+        }
+
+        // Handle additional, undefined properties
+        $additional = $param->getAdditionalProperties();
+        if ($additional instanceof Parameter) {
+            // Process all child elements according to the given schema
+            foreach ($node->children($additional->getData('xmlNs'), true) as $childNode) {
+                $sentAs = $childNode->getName();
+                if (!isset($knownProps[$sentAs])) {
+                    $result[$sentAs] = $this->recursiveProcess(
+                        $additional,
+                        $childNode
+                    );
+                }
+            }
+        } elseif ($additional === null || $additional === true) {
+            // Blindly transform the XML into an array preserving as much data
+            // as possible. Remove processed, aliased properties.
+            $array = array_diff_key(self::xmlToArray($node), $knownProps);
+            // Remove @attributes that were explicitly plucked from the
+            // attributes list.
+            if (isset($array['@attributes']) && $knownAttributes) {
+                $array['@attributes'] = array_diff_key($array['@attributes'], $knownProps);
+                if (!$array['@attributes']) {
+                    unset($array['@attributes']);
+                }
+            }
+
+            // Merge it together with the original result
+            $result = array_merge($array, $result);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Convert an XML document to an array.
+     *
+     * @param \SimpleXMLElement $xml
+     * @param int               $nesting
+     * @param null              $ns
+     *
+     * @return array
+     */
+    private static function xmlToArray(
+        \SimpleXMLElement $xml,
+        $ns = null,
+        $nesting = 0
+    ) {
+        $result = [];
+        $children = $xml->children($ns, true);
+
+        foreach ($children as $name => $child) {
+            $attributes = (array) $child->attributes($ns, true);
+            if (!isset($result[$name])) {
+                $childArray = self::xmlToArray($child, $ns, $nesting + 1);
+                $result[$name] = $attributes
+                    ? array_merge($attributes, $childArray)
+                    : $childArray;
+                continue;
+            }
+            // A child element with this name exists so we're assuming
+            // that the node contains a list of elements
+            if (!is_array($result[$name])) {
+                $result[$name] = [$result[$name]];
+            } elseif (!isset($result[$name][0])) {
+                // Convert the first child into the first element of a numerically indexed array
+                $firstResult = $result[$name];
+                $result[$name] = [];
+                $result[$name][] = $firstResult;
+            }
+            $childArray = self::xmlToArray($child, $ns, $nesting + 1);
+            if ($attributes) {
+                $result[$name][] = array_merge($attributes, $childArray);
+            } else {
+                $result[$name][] = $childArray;
+            }
+        }
+
+        // Extract text from node
+        $text = trim((string) $xml);
+        if ($text === '') {
+            $text = null;
+        }
+
+        // Process attributes
+        $attributes = (array) $xml->attributes($ns, true);
+        if ($attributes) {
+            if ($text !== null) {
+                $result['value'] = $text;
+            }
+            $result = array_merge($attributes, $result);
+        } elseif ($text !== null) {
+            $result = $text;
+        }
+
+        // Make sure we're always returning an array
+        if ($nesting == 0 && !is_array($result)) {
+            $result = [$result];
+        }
+
+        return $result;
+    }
+}

vendor/guzzlehttp/guzzle-services/src/SchemaFormatter.php

@@ -0,0 +1,141 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle;
+
+/**
+ * JSON Schema formatter class
+ */
+class SchemaFormatter
+{
+    /**
+     * Format a value by a registered format name
+     *
+     * @param string $format Registered format used to format the value
+     * @param mixed  $value  Value being formatted
+     *
+     * @return mixed
+     */
+    public function format($format, $value)
+    {
+        switch ($format) {
+            case 'date-time':
+                return $this->formatDateTime($value);
+            case 'date-time-http':
+                return $this->formatDateTimeHttp($value);
+            case 'date':
+                return $this->formatDate($value);
+            case 'time':
+                return $this->formatTime($value);
+            case 'timestamp':
+                return $this->formatTimestamp($value);
+            case 'boolean-string':
+                return $this->formatBooleanAsString($value);
+            default:
+                return $value;
+        }
+    }
+
+    /**
+     * Perform the actual DateTime formatting
+     *
+     * @param int|string|\DateTime $dateTime Date time value
+     * @param string               $format   Format of the result
+     *
+     * @return string
+     * @throws \InvalidArgumentException
+     */
+    protected function dateFormatter($dateTime, $format)
+    {
+        if (is_numeric($dateTime)) {
+            return gmdate($format, (int) $dateTime);
+        }
+
+        if (is_string($dateTime)) {
+            $dateTime = new \DateTime($dateTime);
+        }
+
+        if ($dateTime instanceof \DateTimeInterface) {
+            static $utc;
+            if (!$utc) {
+                $utc = new \DateTimeZone('UTC');
+            }
+            return $dateTime->setTimezone($utc)->format($format);
+        }
+
+        throw new \InvalidArgumentException('Date/Time values must be either '
+            . 'be a string, integer, or DateTime object');
+    }
+
+    /**
+     * Create a ISO 8601 (YYYY-MM-DDThh:mm:ssZ) formatted date time value in
+     * UTC time.
+     *
+     * @param string|integer|\DateTime $value Date time value
+     *
+     * @return string
+     */
+    private function formatDateTime($value)
+    {
+        return $this->dateFormatter($value, 'Y-m-d\TH:i:s\Z');
+    }
+
+    /**
+     * Create an HTTP date (RFC 1123 / RFC 822) formatted UTC date-time string
+     *
+     * @param string|integer|\DateTime $value Date time value
+     *
+     * @return string
+     */
+    private function formatDateTimeHttp($value)
+    {
+        return $this->dateFormatter($value, 'D, d M Y H:i:s \G\M\T');
+    }
+
+    /**
+     * Create a YYYY-MM-DD formatted string
+     *
+     * @param string|integer|\DateTime $value Date time value
+     *
+     * @return string
+     */
+    private function formatDate($value)
+    {
+        return $this->dateFormatter($value, 'Y-m-d');
+    }
+
+    /**
+     * Create a hh:mm:ss formatted string
+     *
+     * @param string|integer|\DateTime $value Date time value
+     *
+     * @return string
+     */
+    private function formatTime($value)
+    {
+        return $this->dateFormatter($value, 'H:i:s');
+    }
+
+    /**
+     * Formats a boolean value as a string
+     *
+     * @param string|integer|bool $value Value to convert to a boolean
+     *                                   'true' / 'false' value
+     *
+     * @return string
+     */
+    private function formatBooleanAsString($value)
+    {
+        return filter_var($value, FILTER_VALIDATE_BOOLEAN) ? 'true' : 'false';
+    }
+
+    /**
+     * Return a UNIX timestamp in the UTC timezone
+     *
+     * @param string|integer|\DateTime $value Time value
+     *
+     * @return int
+     */
+    private function formatTimestamp($value)
+    {
+        return (int) $this->dateFormatter($value, 'U');
+    }
+}

vendor/guzzlehttp/guzzle-services/src/SchemaValidator.php

@@ -0,0 +1,297 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle;
+
+use GuzzleHttp\Command\ToArrayInterface;
+
+/**
+ * Default parameter validator
+ */
+class SchemaValidator
+{
+    /**
+     * Whether or not integers are converted to strings when an integer is
+     * received for a string input
+     *
+     * @var bool
+     */
+    protected $castIntegerToStringType;
+
+    /** @var array Errors encountered while validating */
+    protected $errors;
+
+    /**
+     * @param bool $castIntegerToStringType Set to true to convert integers
+     *     into strings when a required type is a string and the input value is
+     *     an integer. Defaults to true.
+     */
+    public function __construct($castIntegerToStringType = true)
+    {
+        $this->castIntegerToStringType = $castIntegerToStringType;
+    }
+
+    /**
+     * @param Parameter $param
+     * @param $value
+     * @return bool
+     */
+    public function validate(Parameter $param, &$value)
+    {
+        $this->errors = [];
+        $this->recursiveProcess($param, $value);
+
+        if (empty($this->errors)) {
+            return true;
+        } else {
+            sort($this->errors);
+            return false;
+        }
+    }
+
+    /**
+     * Get the errors encountered while validating
+     *
+     * @return array
+     */
+    public function getErrors()
+    {
+        return $this->errors ?: [];
+    }
+
+    /**
+     * From the allowable types, determine the type that the variable matches
+     *
+     * @param string|array $type Parameter type
+     * @param mixed $value Value to determine the type
+     *
+     * @return string|false Returns the matching type on
+     */
+    protected function determineType($type, $value)
+    {
+        foreach ((array) $type as $t) {
+            if ($t == 'string'
+                && (is_string($value) || (is_object($value) && method_exists($value, '__toString')))
+            ) {
+                return 'string';
+            } elseif ($t == 'object' && (is_array($value) || is_object($value))) {
+                return 'object';
+            } elseif ($t == 'array' && is_array($value)) {
+                return 'array';
+            } elseif ($t == 'integer' && is_integer($value)) {
+                return 'integer';
+            } elseif ($t == 'boolean' && is_bool($value)) {
+                return 'boolean';
+            } elseif ($t == 'number' && is_numeric($value)) {
+                return 'number';
+            } elseif ($t == 'numeric' && is_numeric($value)) {
+                return 'numeric';
+            } elseif ($t == 'null' && !$value) {
+                return 'null';
+            } elseif ($t == 'any') {
+                return 'any';
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Recursively validate a parameter
+     *
+     * @param Parameter $param  API parameter being validated
+     * @param mixed     $value  Value to validate and validate. The value may
+     *                          change during this validate.
+     * @param string    $path   Current validation path (used for error reporting)
+     * @param int       $depth  Current depth in the validation validate
+     *
+     * @return bool Returns true if valid, or false if invalid
+     */
+    protected function recursiveProcess(
+        Parameter $param,
+        &$value,
+        $path = '',
+        $depth = 0
+    ) {
+        // Update the value by adding default or static values
+        $value = $param->getValue($value);
+
+        $required = $param->isRequired();
+        // if the value is null and the parameter is not required or is static,
+        // then skip any further recursion
+        if ((null === $value && !$required) || $param->isStatic()) {
+            return true;
+        }
+
+        $type = $param->getType();
+        // Attempt to limit the number of times is_array is called by tracking
+        // if the value is an array
+        $valueIsArray = is_array($value);
+        // If a name is set then update the path so that validation messages
+        // are more helpful
+        if ($name = $param->getName()) {
+            $path .= "[{$name}]";
+        }
+
+        if ($type == 'object') {
+            // Determine whether or not this "value" has properties and should
+            // be traversed
+            $traverse = $temporaryValue = false;
+
+            // Convert the value to an array
+            if (!$valueIsArray && $value instanceof ToArrayInterface) {
+                $value = $value->toArray();
+            }
+
+            if ($valueIsArray) {
+                // Ensure that the array is associative and not numerically
+                // indexed
+                if (isset($value[0])) {
+                    $this->errors[] = "{$path} must be an array of properties. Got a numerically indexed array.";
+                    return false;
+                }
+                $traverse = true;
+            } elseif ($value === null) {
+                // Attempt to let the contents be built up by default values if
+                // possible
+                $value = [];
+                $temporaryValue = $valueIsArray = $traverse = true;
+            }
+
+            if ($traverse) {
+                if ($properties = $param->getProperties()) {
+                    // if properties were found, validate each property
+                    foreach ($properties as $property) {
+                        $name = $property->getName();
+                        if (isset($value[$name])) {
+                            $this->recursiveProcess($property, $value[$name], $path, $depth + 1);
+                        } else {
+                            $current = null;
+                            $this->recursiveProcess($property, $current, $path, $depth + 1);
+                            // Only set the value if it was populated
+                            if (null !== $current) {
+                                $value[$name] = $current;
+                            }
+                        }
+                    }
+                }
+
+                $additional = $param->getAdditionalProperties();
+                if ($additional !== true) {
+                    // If additional properties were found, then validate each
+                    // against the additionalProperties attr.
+                    $keys = array_keys($value);
+                    // Determine the keys that were specified that were not
+                    // listed in the properties of the schema
+                    $diff = array_diff($keys, array_keys($properties));
+                    if (!empty($diff)) {
+                        // Determine which keys are not in the properties
+                        if ($additional instanceof Parameter) {
+                            foreach ($diff as $key) {
+                                $this->recursiveProcess($additional, $value[$key], "{$path}[{$key}]", $depth);
+                            }
+                        } else {
+                            // if additionalProperties is set to false and there
+                            // are additionalProperties in the values, then fail
+                            foreach ($diff as $prop) {
+                                $this->errors[] = sprintf('%s[%s] is not an allowed property', $path, $prop);
+                            }
+                        }
+                    }
+                }
+
+                // A temporary value will be used to traverse elements that
+                // have no corresponding input value. This allows nested
+                // required parameters with default values to bubble up into the
+                // input. Here we check if we used a temp value and nothing
+                // bubbled up, then we need to remote the value.
+                if ($temporaryValue && empty($value)) {
+                    $value = null;
+                    $valueIsArray = false;
+                }
+            }
+
+        } elseif ($type == 'array' && $valueIsArray && $param->getItems()) {
+            foreach ($value as $i => &$item) {
+                // Validate each item in an array against the items attribute of the schema
+                $this->recursiveProcess($param->getItems(), $item, $path . "[{$i}]", $depth + 1);
+            }
+        }
+
+        // If the value is required and the type is not null, then there is an
+        // error if the value is not set
+        if ($required && $value === null && $type != 'null') {
+            $message = "{$path} is " . ($param->getType()
+                ? ('a required ' . implode(' or ', (array) $param->getType()))
+                : 'required');
+            if ($param->has('description')) {
+                $message .= ': ' . $param->getDescription();
+            }
+            $this->errors[] = $message;
+            return false;
+        }
+
+        // Validate that the type is correct. If the type is string but an
+        // integer was passed, the class can be instructed to cast the integer
+        // to a string to pass validation. This is the default behavior.
+        if ($type && (!$type = $this->determineType($type, $value))) {
+            if ($this->castIntegerToStringType
+                && $param->getType() == 'string'
+                && is_integer($value)
+            ) {
+                $value = (string) $value;
+            } else {
+                $this->errors[] = "{$path} must be of type " . implode(' or ', (array) $param->getType());
+            }
+        }
+
+        // Perform type specific validation for strings, arrays, and integers
+        if ($type == 'string') {
+            // Strings can have enums which are a list of predefined values
+            if (($enum = $param->getEnum()) && !in_array($value, $enum)) {
+                $this->errors[] = "{$path} must be one of " . implode(' or ', array_map(function ($s) {
+                        return '"' . addslashes($s) . '"';
+                }, $enum));
+            }
+            // Strings can have a regex pattern that the value must match
+            if (($pattern  = $param->getPattern()) && !preg_match($pattern, $value)) {
+                $this->errors[] = "{$path} must match the following regular expression: {$pattern}";
+            }
+
+            $strLen = null;
+            if ($min = $param->getMinLength()) {
+                $strLen = strlen($value);
+                if ($strLen < $min) {
+                    $this->errors[] = "{$path} length must be greater than or equal to {$min}";
+                }
+            }
+            if ($max = $param->getMaxLength()) {
+                if (($strLen ?: strlen($value)) > $max) {
+                    $this->errors[] = "{$path} length must be less than or equal to {$max}";
+                }
+            }
+
+        } elseif ($type == 'array') {
+            $size = null;
+            if ($min = $param->getMinItems()) {
+                $size = count($value);
+                if ($size < $min) {
+                    $this->errors[] = "{$path} must contain {$min} or more elements";
+                }
+            }
+            if ($max = $param->getMaxItems()) {
+                if (($size ?: count($value)) > $max) {
+                    $this->errors[] = "{$path} must contain {$max} or fewer elements";
+                }
+            }
+
+        } elseif ($type == 'integer' || $type == 'number' || $type == 'numeric') {
+            if (($min = $param->getMinimum()) && $value < $min) {
+                $this->errors[] = "{$path} must be greater than or equal to {$min}";
+            }
+            if (($max = $param->getMaximum()) && $value > $max) {
+                $this->errors[] = "{$path} must be less than or equal to {$max}";
+            }
+        }
+
+        return empty($this->errors);
+    }
+}

vendor/guzzlehttp/guzzle-services/src/Serializer.php

@@ -0,0 +1,166 @@
+<?php
+namespace GuzzleHttp\Command\Guzzle;
+
+use GuzzleHttp\Command\CommandInterface;
+use GuzzleHttp\Command\Guzzle\RequestLocation\BodyLocation;
+use GuzzleHttp\Command\Guzzle\RequestLocation\FormParamLocation;
+use GuzzleHttp\Command\Guzzle\RequestLocation\HeaderLocation;
+use GuzzleHttp\Command\Guzzle\RequestLocation\JsonLocation;
+use GuzzleHttp\Command\Guzzle\RequestLocation\MultiPartLocation;
+use GuzzleHttp\Command\Guzzle\RequestLocation\QueryLocation;
+use GuzzleHttp\Command\Guzzle\RequestLocation\RequestLocationInterface;
+use GuzzleHttp\Command\Guzzle\RequestLocation\XmlLocation;
+use GuzzleHttp\Psr7\Request;
+use GuzzleHttp\Psr7\Uri;
+use GuzzleHttp\Psr7\UriResolver;
+use GuzzleHttp\UriTemplate\UriTemplate;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Serializes requests for a given command.
+ */
+class Serializer
+{
+    /** @var RequestLocationInterface[] */
+    private $locations;
+
+    /** @var DescriptionInterface */
+    private $description;
+
+    /**
+     * @param DescriptionInterface       $description
+     * @param RequestLocationInterface[] $requestLocations Extra request locations
+     */
+    public function __construct(
+        DescriptionInterface $description,
+        array $requestLocations = []
+    ) {
+        static $defaultRequestLocations;
+        if (!$defaultRequestLocations) {
+            $defaultRequestLocations = [
+                'body'      => new BodyLocation(),
+                'query'     => new QueryLocation(),
+                'header'    => new HeaderLocation(),
+                'json'      => new JsonLocation(),
+                'xml'       => new XmlLocation(),
+                'formParam' => new FormParamLocation(),
+                'multipart' => new MultiPartLocation(),
+            ];
+        }
+
+        $this->locations = $requestLocations + $defaultRequestLocations;
+        $this->description = $description;
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @return RequestInterface
+     */
+    public function __invoke(CommandInterface $command)
+    {
+        $request = $this->createRequest($command);
+        return $this->prepareRequest($command, $request);
+    }
+
+    /**
+     * Prepares a request for sending using location visitors
+     *
+     * @param CommandInterface $command
+     * @param RequestInterface $request Request being created
+     * @return RequestInterface
+     * @throws \RuntimeException If a location cannot be handled
+     */
+    protected function prepareRequest(
+        CommandInterface $command,
+        RequestInterface $request
+    ) {
+        $visitedLocations = [];
+        $operation = $this->description->getOperation($command->getName());
+
+        // Visit each actual parameter
+        foreach ($operation->getParams() as $name => $param) {
+            /* @var Parameter $param */
+            $location = $param->getLocation();
+            // Skip parameters that have not been set or are URI location
+            if ($location == 'uri' || !$command->hasParam($name)) {
+                continue;
+            }
+            if (!isset($this->locations[$location])) {
+                throw new \RuntimeException("No location registered for $name");
+            }
+            $visitedLocations[$location] = true;
+            $request = $this->locations[$location]->visit($command, $request, $param);
+        }
+
+        // Ensure that the after() method is invoked for additionalParameters
+        /** @var Parameter $additional */
+        if ($additional = $operation->getAdditionalParameters()) {
+            $visitedLocations[$additional->getLocation()] = true;
+        }
+
+        // Call the after() method for each visited location
+        foreach (array_keys($visitedLocations) as $location) {
+            $request = $this->locations[$location]->after($command, $request, $operation);
+        }
+
+        return $request;
+    }
+
+    /**
+     * Create a request for the command and operation
+     *
+     * @param CommandInterface $command
+     *
+     * @return RequestInterface
+     * @throws \RuntimeException
+     */
+    protected function createRequest(CommandInterface $command)
+    {
+        $operation = $this->description->getOperation($command->getName());
+
+        // If command does not specify a template, assume the client's base URL.
+        if (null === $operation->getUri()) {
+            return new Request(
+                $operation->getHttpMethod() ?: 'GET',
+                $this->description->getBaseUri()
+            );
+        }
+
+        return $this->createCommandWithUri($operation, $command);
+    }
+
+    /**
+     * Create a request for an operation with a uri merged onto a base URI
+     *
+     * @param \GuzzleHttp\Command\Guzzle\Operation $operation
+     * @param \GuzzleHttp\Command\CommandInterface $command
+     *
+     * @return \GuzzleHttp\Psr7\Request
+     */
+    private function createCommandWithUri(
+        Operation $operation,
+        CommandInterface $command
+    ) {
+        // Get the path values and use the client config settings
+        $variables = [];
+        foreach ($operation->getParams() as $name => $arg) {
+            /* @var Parameter $arg */
+            if ($arg->getLocation() == 'uri') {
+                if (isset($command[$name])) {
+                    $variables[$name] = $arg->filter($command[$name]);
+                    if (!is_array($variables[$name])) {
+                        $variables[$name] = (string) $variables[$name];
+                    }
+                }
+            }
+        }
+
+        // Expand the URI template.
+        $uri = new Uri(UriTemplate::expand($operation->getUri(), $variables));
+
+        return new Request(
+            $operation->getHttpMethod() ?: 'GET',
+            UriResolver::resolve($this->description->getBaseUri(), $uri)
+        );
+    }
+}