lockfile again

vendor/aws/aws-sdk-php/CODE_OF_CONDUCT.md

@@ -0,0 +1,4 @@
+## Code of Conduct
+This project has adopted the [Amazon Open Source Code of Conduct](https://aws.github.io/code-of-conduct). 
+For more information see the [Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq) or contact 
+opensource-codeofconduct@amazon.com with any additional questions or comments.

vendor/aws/aws-sdk-php/CRT_INSTRUCTIONS.md

@@ -0,0 +1,4 @@
+## Building and enabling the Common Run Time
+
+1. **Follow instructions on crt repo** – Clone and build the repo as shown [here][https://github.com/awslabs/aws-crt-php].
+1. **Enable the CRT** – add the following line to your php.ini file `extension=path/to/aws-crt-php/modules/awscrt.so`

vendor/aws/aws-sdk-php/LICENSE

@@ -0,0 +1,141 @@
+# Apache License
+Version 2.0, January 2004
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+## 1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1
+through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the
+License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled
+by, or are under common control with that entity. For the purposes of this definition, "control" means
+(i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract
+or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial
+ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software
+source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form,
+including but not limited to compiled object code, generated documentation, and conversions to other media
+types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License,
+as indicated by a copyright notice that is included in or attached to the work (an example is provided in the
+Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from)
+the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent,
+as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not
+include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work
+and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any
+modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to
+Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to
+submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of
+electronic, verbal, or written communication sent to the Licensor or its representatives, including but not
+limited to communication on electronic mailing lists, source code control systems, and issue tracking systems
+that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been
+received by Licensor and subsequently incorporated within the Work.
+
+## 2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare
+Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+## 3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent
+license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such
+license applies only to those patent claims licensable by such Contributor that are necessarily infringed by
+their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such
+Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim
+or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work
+constitutes direct or contributory patent infringement, then any patent licenses granted to You under this
+License for that Work shall terminate as of the date such litigation is filed.
+
+## 4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You meet the following conditions:
+
+   1. You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+   2. You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+   3. You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent,
+	  trademark, and attribution notices from the Source form of the Work, excluding those notices that do
+	  not pertain to any part of the Derivative Works; and
+
+   4. If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that
+	  You distribute must include a readable copy of the attribution notices contained within such NOTICE
+	  file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one
+	  of the following places: within a NOTICE text file distributed as part of the Derivative Works; within
+	  the Source form or documentation, if provided along with the Derivative Works; or, within a display
+	  generated by the Derivative Works, if and wherever such third-party notices normally appear. The
+	  contents of the NOTICE file are for informational purposes only and do not modify the License. You may
+	  add Your own attribution notices within Derivative Works that You distribute, alongside or as an
+	  addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be
+	  construed as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide additional or different license
+terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative
+Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the
+conditions stated in this License.
+
+## 5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by
+You to the Licensor shall be under the terms and conditions of this License, without any additional terms or
+conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate
+license agreement you may have executed with Licensor regarding such Contributions.
+
+## 6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks, service marks, or product names of
+the Licensor, except as required for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+## 7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor
+provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT,
+MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+## 8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless
+required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any
+Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential
+damages of any character arising as a result of this License or out of the use or inability to use the Work
+(including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has been advised of the possibility
+of such damages.
+
+## 9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole
+responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold
+each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

vendor/aws/aws-sdk-php/NOTICE

@@ -0,0 +1,17 @@
+# AWS SDK for PHP
+
+<http://aws.amazon.com/php>
+
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

vendor/aws/aws-sdk-php/THIRD-PARTY-LICENSES

@@ -0,0 +1,84 @@
+The AWS SDK for PHP includes the following third-party software/licensing:
+
+
+** Guzzle - https://github.com/guzzle/guzzle
+
+Copyright (c) 2014 Michael Dowling, https://github.com/mtdowling
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+----------------
+
+** jmespath.php - https://github.com/mtdowling/jmespath.php
+
+Copyright (c) 2014 Michael Dowling, https://github.com/mtdowling
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+----------------
+
+** phpunit-mock-objects -- https://github.com/sebastianbergmann/phpunit-mock-objects
+
+Copyright (c) 2002-2018, Sebastian Bergmann <sebastian@phpunit.de>.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in
+   the documentation and/or other materials provided with the
+   distribution.
+
+ * Neither the name of Sebastian Bergmann nor the names of his
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

vendor/aws/aws-sdk-php/composer.json

@@ -0,0 +1,73 @@
+{
+    "name": "aws/aws-sdk-php",
+    "homepage": "http://aws.amazon.com/sdkforphp",
+    "description": "AWS SDK for PHP - Use Amazon Web Services in your PHP project",
+    "keywords": ["aws","amazon","sdk","s3","ec2","dynamodb","cloud","glacier"],
+    "type": "library",
+    "license": "Apache-2.0",
+    "authors": [
+        {
+            "name": "Amazon Web Services",
+            "homepage": "http://aws.amazon.com"
+        }
+    ],
+    "support": {
+        "forum": "https://github.com/aws/aws-sdk-php/discussions",
+        "issues": "https://github.com/aws/aws-sdk-php/issues"
+    },
+    "require": {
+        "php": ">=8.1",
+        "guzzlehttp/guzzle": "^7.4.5",
+        "guzzlehttp/psr7": "^2.4.5",
+        "guzzlehttp/promises": "^2.0",
+        "mtdowling/jmespath.php": "^2.8.0",
+        "ext-pcre": "*",
+        "ext-json": "*",
+        "ext-simplexml": "*",
+        "aws/aws-crt-php": "^1.2.3",
+        "psr/http-message": "^1.0 || ^2.0"
+    },
+    "require-dev": {
+        "composer/composer" : "^2.7.8",
+        "ext-openssl": "*",
+        "ext-dom": "*",
+        "ext-pcntl": "*",
+        "ext-sockets": "*",
+        "phpunit/phpunit": "^5.6.3 || ^8.5 || ^9.5",
+        "behat/behat": "~3.0",
+        "doctrine/cache": "~1.4",
+        "aws/aws-php-sns-message-validator": "~1.0",
+        "andrewsville/php-token-reflection": "^1.4",
+        "psr/cache": "^2.0 || ^3.0",
+        "psr/simple-cache": "^2.0 || ^3.0",
+        "sebastian/comparator": "^1.2.3 || ^4.0 || ^5.0",
+        "symfony/filesystem": "^v6.4.0 || ^v7.1.0",
+        "yoast/phpunit-polyfills": "^2.0",
+        "dms/phpunit-arraysubset-asserts": "^0.4.0"
+    },
+    "suggest": {
+        "ext-openssl": "Allows working with CloudFront private distributions and verifying received SNS messages",
+        "ext-curl": "To send requests using cURL",
+        "ext-sockets": "To use client-side monitoring",
+        "doctrine/cache": "To use the DoctrineCacheAdapter",
+        "aws/aws-php-sns-message-validator": "To validate incoming SNS notifications"
+    },
+    "autoload": {
+        "psr-4": {
+            "Aws\\": "src/"
+        },
+        "files": ["src/functions.php"],
+        "exclude-from-classmap": ["src/data/"]
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Aws\\Test\\": "tests/"
+        },
+        "classmap": ["build/"]
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "3.0-dev"
+        }
+    }
+}

vendor/aws/aws-sdk-php/src/AIOps/AIOpsClient.php

@@ -0,0 +1,31 @@
+<?php
+namespace Aws\AIOps;
+
+use Aws\AwsClient;
+
+/**
+ * This client is used to interact with the **AWS AI Ops** service.
+ * @method \Aws\Result createInvestigationGroup(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createInvestigationGroupAsync(array $args = [])
+ * @method \Aws\Result deleteInvestigationGroup(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteInvestigationGroupAsync(array $args = [])
+ * @method \Aws\Result deleteInvestigationGroupPolicy(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteInvestigationGroupPolicyAsync(array $args = [])
+ * @method \Aws\Result getInvestigationGroup(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getInvestigationGroupAsync(array $args = [])
+ * @method \Aws\Result getInvestigationGroupPolicy(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getInvestigationGroupPolicyAsync(array $args = [])
+ * @method \Aws\Result listInvestigationGroups(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listInvestigationGroupsAsync(array $args = [])
+ * @method \Aws\Result listTagsForResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listTagsForResourceAsync(array $args = [])
+ * @method \Aws\Result putInvestigationGroupPolicy(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise putInvestigationGroupPolicyAsync(array $args = [])
+ * @method \Aws\Result tagResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise tagResourceAsync(array $args = [])
+ * @method \Aws\Result untagResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise untagResourceAsync(array $args = [])
+ * @method \Aws\Result updateInvestigationGroup(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateInvestigationGroupAsync(array $args = [])
+ */
+class AIOpsClient extends AwsClient {}

vendor/aws/aws-sdk-php/src/AIOps/Exception/AIOpsException.php

@@ -0,0 +1,9 @@
+<?php
+namespace Aws\AIOps\Exception;
+
+use Aws\Exception\AwsException;
+
+/**
+ * Represents an error interacting with the **AWS AI Ops** service.
+ */
+class AIOpsException extends AwsException {}

vendor/aws/aws-sdk-php/src/ARCRegionSwitch/ARCRegionSwitchClient.php

@@ -0,0 +1,49 @@
+<?php
+namespace Aws\ARCRegionSwitch;
+
+use Aws\AwsClient;
+
+/**
+ * This client is used to interact with the **ARC - Region switch** service.
+ * @method \Aws\Result approvePlanExecutionStep(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise approvePlanExecutionStepAsync(array $args = [])
+ * @method \Aws\Result cancelPlanExecution(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise cancelPlanExecutionAsync(array $args = [])
+ * @method \Aws\Result createPlan(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createPlanAsync(array $args = [])
+ * @method \Aws\Result deletePlan(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deletePlanAsync(array $args = [])
+ * @method \Aws\Result getPlan(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getPlanAsync(array $args = [])
+ * @method \Aws\Result getPlanEvaluationStatus(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getPlanEvaluationStatusAsync(array $args = [])
+ * @method \Aws\Result getPlanExecution(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getPlanExecutionAsync(array $args = [])
+ * @method \Aws\Result getPlanInRegion(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getPlanInRegionAsync(array $args = [])
+ * @method \Aws\Result listPlanExecutionEvents(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listPlanExecutionEventsAsync(array $args = [])
+ * @method \Aws\Result listPlanExecutions(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listPlanExecutionsAsync(array $args = [])
+ * @method \Aws\Result listPlans(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listPlansAsync(array $args = [])
+ * @method \Aws\Result listPlansInRegion(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listPlansInRegionAsync(array $args = [])
+ * @method \Aws\Result listRoute53HealthChecks(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listRoute53HealthChecksAsync(array $args = [])
+ * @method \Aws\Result listTagsForResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listTagsForResourceAsync(array $args = [])
+ * @method \Aws\Result startPlanExecution(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise startPlanExecutionAsync(array $args = [])
+ * @method \Aws\Result tagResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise tagResourceAsync(array $args = [])
+ * @method \Aws\Result untagResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise untagResourceAsync(array $args = [])
+ * @method \Aws\Result updatePlan(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updatePlanAsync(array $args = [])
+ * @method \Aws\Result updatePlanExecution(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updatePlanExecutionAsync(array $args = [])
+ * @method \Aws\Result updatePlanExecutionStep(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updatePlanExecutionStepAsync(array $args = [])
+ */
+class ARCRegionSwitchClient extends AwsClient {}

vendor/aws/aws-sdk-php/src/ARCRegionSwitch/Exception/ARCRegionSwitchException.php

@@ -0,0 +1,9 @@
+<?php
+namespace Aws\ARCRegionSwitch\Exception;
+
+use Aws\Exception\AwsException;
+
+/**
+ * Represents an error interacting with the **ARC - Region switch** service.
+ */
+class ARCRegionSwitchException extends AwsException {}

vendor/aws/aws-sdk-php/src/ARCZonalShift/ARCZonalShiftClient.php

@@ -0,0 +1,39 @@
+<?php
+namespace Aws\ARCZonalShift;
+
+use Aws\AwsClient;
+
+/**
+ * This client is used to interact with the **AWS ARC - Zonal Shift** service.
+ * @method \Aws\Result cancelPracticeRun(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise cancelPracticeRunAsync(array $args = [])
+ * @method \Aws\Result cancelZonalShift(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise cancelZonalShiftAsync(array $args = [])
+ * @method \Aws\Result createPracticeRunConfiguration(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createPracticeRunConfigurationAsync(array $args = [])
+ * @method \Aws\Result deletePracticeRunConfiguration(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deletePracticeRunConfigurationAsync(array $args = [])
+ * @method \Aws\Result getAutoshiftObserverNotificationStatus(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getAutoshiftObserverNotificationStatusAsync(array $args = [])
+ * @method \Aws\Result getManagedResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getManagedResourceAsync(array $args = [])
+ * @method \Aws\Result listAutoshifts(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listAutoshiftsAsync(array $args = [])
+ * @method \Aws\Result listManagedResources(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listManagedResourcesAsync(array $args = [])
+ * @method \Aws\Result listZonalShifts(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listZonalShiftsAsync(array $args = [])
+ * @method \Aws\Result startPracticeRun(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise startPracticeRunAsync(array $args = [])
+ * @method \Aws\Result startZonalShift(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise startZonalShiftAsync(array $args = [])
+ * @method \Aws\Result updateAutoshiftObserverNotificationStatus(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateAutoshiftObserverNotificationStatusAsync(array $args = [])
+ * @method \Aws\Result updatePracticeRunConfiguration(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updatePracticeRunConfigurationAsync(array $args = [])
+ * @method \Aws\Result updateZonalAutoshiftConfiguration(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateZonalAutoshiftConfigurationAsync(array $args = [])
+ * @method \Aws\Result updateZonalShift(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateZonalShiftAsync(array $args = [])
+ */
+class ARCZonalShiftClient extends AwsClient {}

vendor/aws/aws-sdk-php/src/ARCZonalShift/Exception/ARCZonalShiftException.php

@@ -0,0 +1,9 @@
+<?php
+namespace Aws\ARCZonalShift\Exception;
+
+use Aws\Exception\AwsException;
+
+/**
+ * Represents an error interacting with the **AWS ARC - Zonal Shift** service.
+ */
+class ARCZonalShiftException extends AwsException {}

vendor/aws/aws-sdk-php/src/AbstractConfigurationProvider.php

@@ -0,0 +1,157 @@
+<?php
+namespace Aws;
+
+use GuzzleHttp\Promise;
+
+/**
+ * A configuration provider is a function that returns a promise that is
+ * fulfilled with a configuration object. This class provides base functionality
+ * usable by specific configuration provider implementations
+ */
+abstract class AbstractConfigurationProvider
+{
+    const ENV_PROFILE = 'AWS_PROFILE';
+    const ENV_CONFIG_FILE = 'AWS_CONFIG_FILE';
+
+    public static $cacheKey;
+
+    protected static $interfaceClass;
+    protected static $exceptionClass;
+
+    /**
+     * Wraps a config provider and saves provided configuration in an
+     * instance of Aws\CacheInterface. Forwards calls when no config found
+     * in cache and updates cache with the results.
+     *
+     * @param callable $provider Configuration provider function to wrap
+     * @param CacheInterface $cache Cache to store configuration
+     * @param string|null $cacheKey (optional) Cache key to use
+     *
+     * @return callable
+     */
+    public static function cache(
+        callable $provider,
+        CacheInterface $cache,
+        $cacheKey = null
+    ) {
+        $cacheKey = $cacheKey ?: static::$cacheKey;
+
+        return function () use ($provider, $cache, $cacheKey) {
+            $found = $cache->get($cacheKey);
+            if ($found instanceof static::$interfaceClass) {
+                return Promise\Create::promiseFor($found);
+            }
+
+            return $provider()
+                ->then(function ($config) use (
+                    $cache,
+                    $cacheKey
+                ) {
+                    $cache->set($cacheKey, $config);
+                    return $config;
+                });
+        };
+    }
+
+    /**
+     * Creates an aggregate configuration provider that invokes the provided
+     * variadic providers one after the other until a provider returns
+     * configuration.
+     *
+     * @return callable
+     */
+    public static function chain()
+    {
+        $links = func_get_args();
+        if (empty($links)) {
+            throw new \InvalidArgumentException('No providers in chain');
+        }
+
+        return function () use ($links) {
+            /** @var callable $parent */
+            $parent = array_shift($links);
+            $promise = $parent();
+            while ($next = array_shift($links)) {
+                $promise = $promise->otherwise($next);
+            }
+            return $promise;
+        };
+    }
+
+    /**
+     * Gets the environment's HOME directory if available.
+     *
+     * @return null|string
+     */
+    protected static function getHomeDir()
+    {
+        // On Linux/Unix-like systems, use the HOME environment variable
+        if ($homeDir = getenv('HOME')) {
+            return $homeDir;
+        }
+
+        // Get the HOMEDRIVE and HOMEPATH values for Windows hosts
+        $homeDrive = getenv('HOMEDRIVE');
+        $homePath = getenv('HOMEPATH');
+
+        return ($homeDrive && $homePath) ? $homeDrive . $homePath : null;
+    }
+
+    /**
+     * Gets default config file location from environment, falling back to aws
+     * default location
+     *
+     * @return string
+     */
+    protected static function getDefaultConfigFilename()
+    {
+        if ($filename = getenv(self::ENV_CONFIG_FILE)) {
+            return $filename;
+        }
+        return self::getHomeDir() . '/.aws/config';
+    }
+
+    /**
+     * Wraps a config provider and caches previously provided configuration.
+     *
+     * @param callable $provider Config provider function to wrap.
+     *
+     * @return callable
+     */
+    public static function memoize(callable $provider)
+    {
+        return function () use ($provider) {
+            static $result;
+            static $isConstant;
+
+            // Constant config will be returned constantly.
+            if ($isConstant) {
+                return $result;
+            }
+
+            // Create the initial promise that will be used as the cached value
+            if (null === $result) {
+                $result = $provider();
+            }
+
+            // Return config and set flag that provider is already set
+            return $result
+                ->then(function ($config) use (&$isConstant) {
+                    $isConstant = true;
+                    return $config;
+                });
+        };
+    }
+
+    /**
+     * Reject promise with standardized exception.
+     *
+     * @param $msg
+     * @return Promise\RejectedPromise
+     */
+    protected static function reject($msg)
+    {
+        $exceptionClass = static::$exceptionClass;
+        return new Promise\RejectedPromise(new $exceptionClass($msg));
+    }
+}

vendor/aws/aws-sdk-php/src/Api/AbstractModel.php

@@ -0,0 +1,89 @@
+<?php
+namespace Aws\Api;
+
+/**
+ * Base class that is used by most API shapes
+ */
+abstract class AbstractModel implements \ArrayAccess
+{
+    /** @var array */
+    protected $definition;
+
+    /** @var ShapeMap */
+    protected $shapeMap;
+
+    /** @var array */
+    protected $contextParam;
+
+    /**
+     * @param array    $definition Service description
+     * @param ShapeMap $shapeMap   Shapemap used for creating shapes
+     */
+    public function __construct(array $definition, ShapeMap $shapeMap)
+    {
+        $this->definition = $definition;
+        $this->shapeMap = $shapeMap;
+        if (isset($definition['contextParam'])) {
+            $this->contextParam = $definition['contextParam'];
+        }
+    }
+
+    public function toArray()
+    {
+        return $this->definition;
+    }
+
+    /**
+     * @return mixed|null
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetGet($offset)
+    {
+        return isset($this->definition[$offset])
+            ? $this->definition[$offset] : null;
+    }
+
+    /**
+     * @return void
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetSet($offset, $value)
+    {
+        $this->definition[$offset] = $value;
+    }
+
+    /**
+     * @return bool
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetExists($offset)
+    {
+        return isset($this->definition[$offset]);
+    }
+
+    /**
+     * @return void
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetUnset($offset)
+    {
+        unset($this->definition[$offset]);
+    }
+
+    protected function shapeAt($key)
+    {
+        if (!isset($this->definition[$key])) {
+            throw new \InvalidArgumentException('Expected shape definition at '
+                . $key);
+        }
+
+        return $this->shapeFor($this->definition[$key]);
+    }
+
+    protected function shapeFor(array $definition)
+    {
+        return isset($definition['shape'])
+            ? $this->shapeMap->resolve($definition)
+            : Shape::create($definition, $this->shapeMap);
+    }
+}

vendor/aws/aws-sdk-php/src/Api/ApiProvider.php

@@ -0,0 +1,244 @@
+<?php
+namespace Aws\Api;
+
+use Aws\Exception\UnresolvedApiException;
+
+/**
+ * API providers.
+ *
+ * An API provider is a function that accepts a type, service, and version and
+ * returns an array of API data on success or NULL if no API data can be created
+ * for the provided arguments.
+ *
+ * You can wrap your calls to an API provider with the
+ * {@see ApiProvider::resolve} method to ensure that API data is created. If the
+ * API data is not created, then the resolve() method will throw a
+ * {@see Aws\Exception\UnresolvedApiException}.
+ *
+ *     use Aws\Api\ApiProvider;
+ *     $provider = ApiProvider::defaultProvider();
+ *     // Returns an array or NULL.
+ *     $data = $provider('api', 's3', '2006-03-01');
+ *     // Returns an array or throws.
+ *     $data = ApiProvider::resolve($provider, 'api', 'elasticfood', '2020-01-01');
+ *
+ * You can compose multiple providers into a single provider using
+ * {@see Aws\or_chain}. This method accepts providers as arguments and
+ * returns a new function that will invoke each provider until a non-null value
+ * is returned.
+ *
+ *     $a = ApiProvider::filesystem(sys_get_temp_dir() . '/aws-beta-models');
+ *     $b = ApiProvider::manifest();
+ *
+ *     $c = \Aws\or_chain($a, $b);
+ *     $data = $c('api', 'betaservice', '2015-08-08'); // $a handles this.
+ *     $data = $c('api', 's3', '2006-03-01');          // $b handles this.
+ *     $data = $c('api', 'invalid', '2014-12-15');     // Neither handles this.
+ */
+class ApiProvider
+{
+    /** @var array A map of public API type names to their file suffix. */
+    private static $typeMap = [
+        'api'       => 'api-2',
+        'paginator' => 'paginators-1',
+        'waiter'    => 'waiters-2',
+        'docs'      => 'docs-2',
+    ];
+
+    /** @var array API manifest */
+    private $manifest;
+
+    /** @var string The directory containing service models. */
+    private $modelsDir;
+
+    /**
+     * Resolves an API provider and ensures a non-null return value.
+     *
+     * @param callable $provider Provider function to invoke.
+     * @param string   $type     Type of data ('api', 'waiter', 'paginator').
+     * @param string   $service  Service name.
+     * @param string   $version  API version.
+     *
+     * @return array
+     * @throws UnresolvedApiException
+     */
+    public static function resolve(callable $provider, $type, $service, $version)
+    {
+        // Execute the provider and return the result, if there is one.
+        $result = $provider($type, $service, $version);
+        if (is_array($result)) {
+            if (!isset($result['metadata']['serviceIdentifier'])) {
+                $result['metadata']['serviceIdentifier'] = $service;
+            }
+            return $result;
+        }
+
+        // Throw an exception with a message depending on the inputs.
+        if (!isset(self::$typeMap[$type])) {
+            $msg = "The type must be one of: " . implode(', ', self::$typeMap);
+        } elseif ($service) {
+            $msg = "The {$service} service does not have version: {$version}.";
+        } else {
+            $msg = "You must specify a service name to retrieve its API data.";
+        }
+
+        throw new UnresolvedApiException($msg);
+    }
+
+    /**
+     * Default SDK API provider.
+     *
+     * This provider loads pre-built manifest data from the `data` directory.
+     *
+     * @return self
+     */
+    public static function defaultProvider()
+    {
+        return new self(__DIR__ . '/../data', \Aws\manifest());
+    }
+
+    /**
+     * Loads API data after resolving the version to the latest, compatible,
+     * available version based on the provided manifest data.
+     *
+     * Manifest data is essentially an associative array of service names to
+     * associative arrays of API version aliases.
+     *
+     * [
+     *   ...
+     *   'ec2' => [
+     *     'latest'     => '2014-10-01',
+     *     '2014-10-01' => '2014-10-01',
+     *     '2014-09-01' => '2014-10-01',
+     *     '2014-06-15' => '2014-10-01',
+     *     ...
+     *   ],
+     *   'ecs' => [...],
+     *   'elasticache' => [...],
+     *   ...
+     * ]
+     *
+     * @param string $dir      Directory containing service models.
+     * @param array  $manifest The API version manifest data.
+     *
+     * @return self
+     */
+    public static function manifest($dir, array $manifest)
+    {
+        return new self($dir, $manifest);
+    }
+
+    /**
+     * Loads API data from the specified directory.
+     *
+     * If "latest" is specified as the version, this provider must glob the
+     * directory to find which is the latest available version.
+     *
+     * @param string $dir Directory containing service models.
+     *
+     * @return self
+     * @throws \InvalidArgumentException if the provided `$dir` is invalid.
+     */
+    public static function filesystem($dir)
+    {
+        return new self($dir);
+    }
+
+    /**
+     * Retrieves a list of valid versions for the specified service.
+     *
+     * @param string $service Service name
+     *
+     * @return array
+     */
+    public function getVersions($service)
+    {
+        if (!isset($this->manifest)) {
+            $this->buildVersionsList($service);
+        }
+
+        if (!isset($this->manifest[$service]['versions'])) {
+            return [];
+        }
+
+        return array_values(array_unique($this->manifest[$service]['versions']));
+    }
+
+    /**
+     * Execute the provider.
+     *
+     * @param string $type    Type of data ('api', 'waiter', 'paginator').
+     * @param string $service Service name.
+     * @param string $version API version.
+     *
+     * @return array|null
+     */
+    public function __invoke($type, $service, $version)
+    {
+        // Resolve the type or return null.
+        if (isset(self::$typeMap[$type])) {
+            $type = self::$typeMap[$type];
+        } else {
+            return null;
+        }
+
+        // Resolve the version or return null.
+        if (!isset($this->manifest)) {
+            $this->buildVersionsList($service);
+        }
+
+        if (!isset($this->manifest[$service]['versions'][$version])) {
+            return null;
+        }
+
+        $version = $this->manifest[$service]['versions'][$version];
+        $path = "{$this->modelsDir}/{$service}/{$version}/{$type}.json";
+
+        try {
+            return \Aws\load_compiled_json($path);
+        } catch (\InvalidArgumentException $e) {
+            return null;
+        }
+    }
+
+    /**
+     * @param string $modelsDir Directory containing service models.
+     * @param array  $manifest  The API version manifest data.
+     */
+    private function __construct($modelsDir, ?array $manifest = null)
+    {
+        $this->manifest = $manifest;
+        $this->modelsDir = rtrim($modelsDir, '/');
+        if (!is_dir($this->modelsDir)) {
+            throw new \InvalidArgumentException(
+                "The specified models directory, {$modelsDir}, was not found."
+            );
+        }
+    }
+
+    /**
+     * Build the versions list for the specified service by globbing the dir.
+     */
+    private function buildVersionsList($service)
+    {
+        $dir = "{$this->modelsDir}/{$service}/";
+
+        if (!is_dir($dir)) {
+            return;
+        }
+
+        // Get versions, remove . and .., and sort in descending order.
+        $results = array_diff(scandir($dir, SCANDIR_SORT_DESCENDING), ['..', '.']);
+
+        if (!$results) {
+            $this->manifest[$service] = ['versions' => []];
+        } else {
+            $this->manifest[$service] = [
+                'versions' => [
+                    'latest' => $results[0]
+                ]
+            ];
+            $this->manifest[$service]['versions'] += array_combine($results, $results);
+        }
+    }
+}

vendor/aws/aws-sdk-php/src/Api/DateTimeResult.php

@@ -0,0 +1,134 @@
+<?php
+
+namespace Aws\Api;
+
+use Aws\Api\Parser\Exception\ParserException;
+use DateTime;
+use DateTimeZone;
+use Exception;
+
+/**
+ * DateTime overrides that make DateTime work more seamlessly as a string,
+ * with JSON documents, and with JMESPath.
+ */
+class DateTimeResult extends \DateTime implements \JsonSerializable
+{
+    private const ISO8601_NANOSECOND_REGEX = '/^(.*\.\d{6})(\d{1,3})(Z|[+-]\d{2}:\d{2})?$/';
+
+    /**
+     * Create a new DateTimeResult from a unix timestamp.
+     * The Unix epoch (or Unix time or POSIX time or Unix
+     * timestamp) is the number of seconds that have elapsed since
+     * January 1, 1970 (midnight UTC/GMT).
+     *
+     * @return DateTimeResult
+     * @throws Exception
+     */
+    public static function fromEpoch($unixTimestamp)
+    {
+        if (!is_numeric($unixTimestamp)) {
+            throw new ParserException('Invalid timestamp value passed to DateTimeResult::fromEpoch');
+        }
+
+        // PHP 5.5 does not support sub-second precision
+        if (\PHP_VERSION_ID < 56000) {
+            return new self(gmdate('c', $unixTimestamp));
+        }
+
+        $decimalSeparator = isset(localeconv()['decimal_point']) ? localeconv()['decimal_point'] : ".";
+        $formatString = "U" . $decimalSeparator . "u";
+        $dateTime = DateTime::createFromFormat(
+            $formatString,
+            sprintf('%0.6f', $unixTimestamp),
+            new DateTimeZone('UTC')
+        );
+
+        if (false === $dateTime) {
+            throw new ParserException('Invalid timestamp value passed to DateTimeResult::fromEpoch');
+        }
+
+        return new self(
+            $dateTime->format('Y-m-d H:i:s.u'),
+            new DateTimeZone('UTC')
+        );
+    }
+
+    /**
+     * @return DateTimeResult
+     */
+    public static function fromISO8601($iso8601Timestamp)
+    {
+        if (is_numeric($iso8601Timestamp) || !is_string($iso8601Timestamp)) {
+            throw new ParserException('Invalid timestamp value passed to DateTimeResult::fromISO8601');
+        }
+
+        // Prior to 8.0.10, nanosecond precision is not supported
+        // Reduces to microsecond precision if nanosecond precision is detected
+        if (PHP_VERSION_ID < 80010
+            && preg_match(self::ISO8601_NANOSECOND_REGEX, $iso8601Timestamp, $matches)
+        ) {
+            $iso8601Timestamp = $matches[1] . ($matches[3] ?? '');
+        }
+
+        return new DateTimeResult($iso8601Timestamp);
+    }
+
+    /**
+     * Create a new DateTimeResult from an unknown timestamp.
+     *
+     * @return DateTimeResult
+     * @throws Exception
+     */
+    public static function fromTimestamp($timestamp, $expectedFormat = null)
+    {
+        if (empty($timestamp)) {
+            return self::fromEpoch(0);
+        }
+
+        if (!(is_string($timestamp) || is_numeric($timestamp))) {
+            throw new ParserException('Invalid timestamp value passed to DateTimeResult::fromTimestamp');
+        }
+
+        try {
+            if ($expectedFormat == 'iso8601') {
+                try {
+                    return self::fromISO8601($timestamp);
+                } catch (Exception $exception) {
+                    return self::fromEpoch($timestamp);
+                }
+            } else if ($expectedFormat == 'unixTimestamp') {
+                try {
+                    return self::fromEpoch($timestamp);
+                } catch (Exception $exception) {
+                    return self::fromISO8601($timestamp);
+                }
+            } else if (\Aws\is_valid_epoch($timestamp)) {
+                return self::fromEpoch($timestamp);
+            }
+            return self::fromISO8601($timestamp);
+        } catch (Exception $exception) {
+            throw new ParserException('Invalid timestamp value passed to DateTimeResult::fromTimestamp');
+        }
+    }
+
+    /**
+     * Serialize the DateTimeResult as an ISO 8601 date string.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->format('c');
+    }
+
+    /**
+     * Serialize the date as an ISO 8601 date when serializing as JSON.
+     *
+     * @return string
+     */
+    #[\ReturnTypeWillChange]
+    public function jsonSerialize()
+    {
+        return (string) $this;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/DocModel.php

@@ -0,0 +1,139 @@
+<?php
+namespace Aws\Api;
+
+/**
+ * Encapsulates the documentation strings for a given service-version and
+ * provides methods for extracting the desired parts related to a service,
+ * operation, error, or shape (i.e., parameter).
+ */
+class DocModel
+{
+    /** @var array */
+    private $docs;
+
+    /**
+     * @param array $docs
+     *
+     * @throws \RuntimeException
+     */
+    public function __construct(array $docs)
+    {
+        if (!extension_loaded('tidy')) {
+            throw new \RuntimeException('The "tidy" PHP extension is required.');
+        }
+
+        $this->docs = $docs;
+    }
+
+    /**
+     * Convert the doc model to an array.
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        return $this->docs;
+    }
+
+    /**
+     * Retrieves documentation about the service.
+     *
+     * @return null|string
+     */
+    public function getServiceDocs()
+    {
+        return isset($this->docs['service']) ? $this->docs['service'] : null;
+    }
+
+    /**
+     * Retrieves documentation about an operation.
+     *
+     * @param string $operation Name of the operation
+     *
+     * @return null|string
+     */
+    public function getOperationDocs($operation)
+    {
+        return isset($this->docs['operations'][$operation])
+            ? $this->docs['operations'][$operation]
+            : null;
+    }
+
+    /**
+     * Retrieves documentation about an error.
+     *
+     * @param string $error Name of the error
+     *
+     * @return null|string
+     */
+    public function getErrorDocs($error)
+    {
+        return isset($this->docs['shapes'][$error]['base'])
+            ? $this->docs['shapes'][$error]['base']
+            : null;
+    }
+
+    /**
+     * Retrieves documentation about a shape, specific to the context.
+     *
+     * @param string $shapeName  Name of the shape.
+     * @param string $parentName Name of the parent/context shape.
+     * @param string $ref        Name used by the context to reference the shape.
+     *
+     * @return null|string
+     */
+    public function getShapeDocs($shapeName, $parentName, $ref)
+    {
+        if (!isset($this->docs['shapes'][$shapeName])) {
+            return '';
+        }
+
+        $result = '';
+        $d = $this->docs['shapes'][$shapeName];
+        if (isset($d['refs']["{$parentName}\${$ref}"])) {
+            $result = $d['refs']["{$parentName}\${$ref}"];
+        } elseif (isset($d['base'])) {
+            $result = $d['base'];
+        }
+
+        if (isset($d['append'])) {
+            if (!isset($d['excludeAppend'])
+                || !in_array($parentName, $d['excludeAppend'])
+            ) {
+                $result .= $d['append'];
+            }
+        }
+
+        if (isset($d['appendOnly'])
+           && in_array($parentName, $d['appendOnly']['shapes'])
+        ) {
+            $result .= $d['appendOnly']['message'];
+        }
+
+        return $this->clean($result);
+    }
+
+
+    private function clean($content)
+    {
+        if (!$content) {
+            return '';
+        }
+
+        $tidy = new \tidy();
+        $tidy->parseString($content, [
+            'indent' => true,
+            'doctype' => 'omit',
+            'output-html' => true,
+            'show-body-only' => true,
+            'drop-empty-paras' => true,
+            'clean' => true,
+            'drop-proprietary-attributes' => true,
+            'hide-comments' => true,
+            'logical-emphasis' => true
+        ]);
+        $tidy->cleanRepair();
+
+        return (string) $content;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/ErrorParser/AbstractErrorParser.php

@@ -0,0 +1,99 @@
+<?php
+namespace Aws\Api\ErrorParser;
+
+use Aws\Api\Parser\MetadataParserTrait;
+use Aws\Api\Parser\PayloadParserTrait;
+use Aws\Api\Service;
+use Aws\Api\StructureShape;
+use Aws\CommandInterface;
+use Psr\Http\Message\ResponseInterface;
+
+abstract class AbstractErrorParser
+{
+    use MetadataParserTrait;
+    use PayloadParserTrait;
+
+    /**
+     * @var Service
+     */
+    protected $api;
+
+    /**
+     * @param Service $api
+     */
+    public function __construct(?Service $api = null)
+    {
+        $this->api = $api;
+    }
+
+    abstract protected function payload(
+        ResponseInterface $response,
+        StructureShape $member
+    );
+
+    protected function extractPayload(
+        StructureShape $member,
+        ResponseInterface $response
+    ) {
+        if ($member instanceof StructureShape) {
+            // Structure members parse top-level data into a specific key.
+            return $this->payload($response, $member);
+        } else {
+            // Streaming data is just the stream from the response body.
+            return $response->getBody();
+        }
+    }
+
+    protected function populateShape(
+        array &$data,
+        ResponseInterface $response,
+        ?CommandInterface $command = null
+    ) {
+        $data['body'] = [];
+
+        if (!empty($command) && !empty($this->api)) {
+
+            // If modeled error code is indicated, check for known error shape
+            if (!empty($data['code'])) {
+
+                $errors = $this->api->getOperation($command->getName())->getErrors();
+                foreach ($errors as $key => $error) {
+
+                    // If error code matches a known error shape, populate the body
+                    if ($this->errorCodeMatches($data, $error)) {
+                        $modeledError = $error;
+                        $data['body'] = $this->extractPayload(
+                            $modeledError,
+                            $response
+                        );
+                        $data['error_shape'] = $modeledError;
+
+                        foreach ($error->getMembers() as $name => $member) {
+                            switch ($member['location']) {
+                                case 'header':
+                                    $this->extractHeader($name, $member, $response, $data['body']);
+                                    break;
+                                case 'headers':
+                                    $this->extractHeaders($name, $member, $response, $data['body']);
+                                    break;
+                                case 'statusCode':
+                                    $this->extractStatus($name, $response, $data['body']);
+                                    break;
+                            }
+                        }
+
+                        break;
+                    }
+                }
+            }
+        }
+
+        return $data;
+    }
+
+    private function errorCodeMatches(array $data, $error): bool
+    {
+        return $data['code'] == $error['name']
+            || (isset($error['error']['code']) && $data['code'] === $error['error']['code']);
+    }
+}

vendor/aws/aws-sdk-php/src/Api/ErrorParser/JsonParserTrait.php

@@ -0,0 +1,144 @@
+<?php
+namespace Aws\Api\ErrorParser;
+
+use Aws\Api\Parser\PayloadParserTrait;
+use Aws\Api\StructureShape;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Provides basic JSON error parsing functionality.
+ */
+trait JsonParserTrait
+{
+    use PayloadParserTrait;
+
+    private function genericHandler(ResponseInterface $response): array
+    {
+        $code = (string) $response->getStatusCode();
+        $error_code = null;
+        $error_type = null;
+
+        // Parse error code and type for query compatible services
+        if ($this->api
+            && !is_null($this->api->getMetadata('awsQueryCompatible'))
+            && $response->hasHeader('x-amzn-query-error')
+        ) {
+            $awsQueryError = $this->parseAwsQueryCompatibleHeader($response);
+            if ($awsQueryError) {
+                $error_code = $awsQueryError['code'];
+                $error_type = $awsQueryError['type'];
+            }
+        }
+
+        // Parse error code from X-Amzn-Errortype header
+        if (!$error_code && $response->hasHeader('X-Amzn-Errortype')) {
+            $error_code = $this->extractErrorCode(
+                $response->getHeaderLine('X-Amzn-Errortype')
+            );
+        }
+
+        $parsedBody = null;
+        $body = $response->getBody();
+        if (!$body->isSeekable() || $body->getSize()) {
+            $parsedBody = $this->parseJson((string) $body, $response);
+        }
+
+        // Parse error code from response body
+        if (!$error_code && $parsedBody) {
+            $error_code = $this->parseErrorFromBody($parsedBody);
+        }
+
+        if (!isset($error_type)) {
+            $error_type = $code[0] == '4' ? 'client' : 'server';
+        }
+
+        return [
+            'request_id'  => $response->getHeaderLine('x-amzn-requestid'),
+            'code'        => $error_code ?? null,
+            'message'     => null,
+            'type'        => $error_type,
+            'parsed'      => $parsedBody
+        ];
+    }
+
+    /**
+     * Parse AWS Query Compatible error from header
+     *
+     * @param ResponseInterface $response
+     * @return array|null Returns ['code' => string, 'type' => string] or null
+     */
+    private function parseAwsQueryCompatibleHeader(ResponseInterface $response): ?array
+    {
+        $queryError = $response->getHeaderLine('x-amzn-query-error');
+        $parts = explode(';', $queryError);
+
+        if (count($parts) === 2 && $parts[0] && $parts[1]) {
+            return [
+                'code' => $parts[0],
+                'type' => $parts[1]
+            ];
+        }
+
+        return null;
+    }
+
+    /**
+     * Parse error code from response body
+     *
+     * @param array|null $parsedBody
+     * @return string|null
+     */
+    private function parseErrorFromBody(?array $parsedBody): ?string
+    {
+        if (!$parsedBody
+            || (!isset($parsedBody['code']) && !isset($parsedBody['__type']))
+        ) {
+            return null;
+        }
+
+        $error_code = $parsedBody['code'] ?? $parsedBody['__type'];
+        return $this->extractErrorCode($error_code);
+    }
+
+    /**
+     * Extract error code from raw error string containing # and/or : delimiters
+     *
+     * @param string $rawErrorCode
+     * @return string
+     */
+    private function extractErrorCode(string $rawErrorCode): string
+    {
+        // Handle format with both # and uri (e.g., "namespace#http://foo-bar")
+        if (str_contains($rawErrorCode, ':') && str_contains($rawErrorCode, '#')) {
+            $start = strpos($rawErrorCode, '#') + 1;
+            $end = strpos($rawErrorCode, ':', $start);
+            return substr($rawErrorCode, $start, $end - $start);
+        }
+
+        // Handle format with uri only : (e.g., "ErrorCode:http://foo-bar.com/baz")
+        if (str_contains($rawErrorCode, ':')) {
+            return substr($rawErrorCode, 0, strpos($rawErrorCode, ':'));
+        }
+
+        // Handle format with only # (e.g., "namespace#ErrorCode")
+        if (str_contains($rawErrorCode, '#')) {
+            return substr($rawErrorCode, strpos($rawErrorCode, '#') + 1);
+        }
+
+        return $rawErrorCode;
+    }
+
+    protected function payload(
+        ResponseInterface $response,
+        StructureShape $member
+    ) {
+        $body = $response->getBody();
+        if (!$body->isSeekable() || $body->getSize()) {
+            $jsonBody = $this->parseJson($body, $response);
+        } else {
+            $jsonBody = (string) $body;
+        }
+
+        return $this->parser->parse($member, $jsonBody);
+    }
+}

vendor/aws/aws-sdk-php/src/Api/ErrorParser/JsonRpcErrorParser.php

@@ -0,0 +1,47 @@
+<?php
+namespace Aws\Api\ErrorParser;
+
+use Aws\Api\Parser\JsonParser;
+use Aws\Api\Service;
+use Aws\CommandInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Parsers JSON-RPC errors.
+ */
+class JsonRpcErrorParser extends AbstractErrorParser
+{
+    use JsonParserTrait;
+
+    private $parser;
+
+    public function __construct(?Service $api = null, ?JsonParser $parser = null)
+    {
+        parent::__construct($api);
+        $this->parser = $parser ?: new JsonParser();
+    }
+
+    public function __invoke(
+        ResponseInterface $response,
+        ?CommandInterface $command = null
+    ) {
+        $data = $this->genericHandler($response);
+
+        // Make the casing consistent across services.
+        if ($data['parsed']) {
+            $data['parsed'] = array_change_key_case($data['parsed']);
+        }
+
+        if (isset($data['parsed']['__type'])) {
+            if (!isset($data['code'])) {
+                $parts = explode('#', $data['parsed']['__type']);
+                $data['code'] = isset($parts[1]) ? $parts[1] : $parts[0];
+            }
+            $data['message'] = $data['parsed']['message'] ?? null;
+        }
+
+        $this->populateShape($data, $response, $command);
+
+        return $data;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/ErrorParser/RestJsonErrorParser.php

@@ -0,0 +1,49 @@
+<?php
+namespace Aws\Api\ErrorParser;
+
+use Aws\Api\Parser\JsonParser;
+use Aws\Api\Service;
+use Aws\Api\StructureShape;
+use Aws\CommandInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Parses JSON-REST errors.
+ */
+class RestJsonErrorParser extends AbstractErrorParser
+{
+    use JsonParserTrait;
+
+    private $parser;
+
+    public function __construct(?Service $api = null, ?JsonParser $parser = null)
+    {
+        parent::__construct($api);
+        $this->parser = $parser ?: new JsonParser();
+    }
+
+    public function __invoke(
+        ResponseInterface $response,
+        ?CommandInterface $command = null
+    ) {
+        $data = $this->genericHandler($response);
+
+        // Merge in error data from the JSON body
+        if ($json = $data['parsed']) {
+            $data = array_replace($json, $data);
+        }
+
+        // Correct error type from services like Amazon Glacier
+        if (!empty($data['type'])) {
+            $data['type'] = strtolower($data['type']);
+        }
+
+        // Retrieve error message directly
+        $data['message'] = $data['parsed']['message']
+            ?? ($data['parsed']['Message'] ?? null);
+
+        $this->populateShape($data, $response, $command);
+
+        return $data;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/ErrorParser/XmlErrorParser.php

@@ -0,0 +1,111 @@
+<?php
+namespace Aws\Api\ErrorParser;
+
+use Aws\Api\Parser\PayloadParserTrait;
+use Aws\Api\Parser\XmlParser;
+use Aws\Api\Service;
+use Aws\Api\StructureShape;
+use Aws\CommandInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Parses XML errors.
+ */
+class XmlErrorParser extends AbstractErrorParser
+{
+    use PayloadParserTrait;
+
+    protected $parser;
+
+    public function __construct(?Service $api = null, ?XmlParser $parser = null)
+    {
+        parent::__construct($api);
+        $this->parser = $parser ?: new XmlParser();
+    }
+
+    public function __invoke(
+        ResponseInterface $response,
+        ?CommandInterface $command = null
+    ) {
+        $code = (string) $response->getStatusCode();
+
+        $data = [
+            'type' => $code[0] == '4' ? 'client' : 'server',
+            'request_id' => null,
+            'code' => null,
+            'message' => null,
+            'parsed' => null
+        ];
+
+        $body = $response->getBody();
+        if ($body->getSize() > 0) {
+            $this->parseBody($this->parseXml($body, $response), $data);
+        } else {
+            $this->parseHeaders($response, $data);
+        }
+
+        $this->populateShape($data, $response, $command);
+
+        return $data;
+    }
+
+    private function parseHeaders(ResponseInterface $response, array &$data)
+    {
+        if ($response->getStatusCode() == '404') {
+            $data['code'] = 'NotFound';
+        }
+
+        $data['message'] = $response->getStatusCode() . ' '
+            . $response->getReasonPhrase();
+
+        if ($requestId = $response->getHeaderLine('x-amz-request-id')) {
+            $data['request_id'] = $requestId;
+            $data['message'] .= " (Request-ID: $requestId)";
+        }
+    }
+
+    private function parseBody(\SimpleXMLElement $body, array &$data)
+    {
+        $data['parsed'] = $body;
+        $prefix = $this->registerNamespacePrefix($body);
+
+        if ($tempXml = $body->xpath("//{$prefix}Code[1]")) {
+            $data['code'] = (string) $tempXml[0];
+        }
+
+        if ($tempXml = $body->xpath("//{$prefix}Message[1]")) {
+            $data['message'] = (string) $tempXml[0];
+        }
+
+        $tempXml = $body->xpath("//{$prefix}RequestId[1]");
+        if (isset($tempXml[0])) {
+            $data['request_id'] = (string)$tempXml[0];
+        }
+    }
+
+    protected function registerNamespacePrefix(\SimpleXMLElement $element)
+    {
+        $namespaces = $element->getDocNamespaces();
+        if (!isset($namespaces[''])) {
+            return '';
+        } 
+        
+        // Account for the default namespace being defined and PHP not
+        // being able to handle it :(.
+        $element->registerXPathNamespace('ns', $namespaces['']);
+        return 'ns:';
+    }
+
+    protected function payload(
+        ResponseInterface $response,
+        StructureShape $member
+    ) {
+        $xmlBody = $this->parseXml($response->getBody(), $response);
+        $prefix = $this->registerNamespacePrefix($xmlBody);
+        $errorBody = $xmlBody->xpath("//{$prefix}Error");
+
+        if (is_array($errorBody) && !empty($errorBody[0])) {
+            return $this->parser->parse($member, $errorBody[0]);
+        }
+    }
+}

vendor/aws/aws-sdk-php/src/Api/ListShape.php

@@ -0,0 +1,35 @@
+<?php
+namespace Aws\Api;
+
+/**
+ * Represents a list shape.
+ */
+class ListShape extends Shape
+{
+    private $member;
+
+    public function __construct(array $definition, ShapeMap $shapeMap)
+    {
+        $definition['type'] = 'list';
+        parent::__construct($definition, $shapeMap);
+    }
+
+    /**
+     * @return Shape
+     * @throws \RuntimeException if no member is specified
+     */
+    public function getMember()
+    {
+        if (!$this->member) {
+            if (!isset($this->definition['member'])) {
+                throw new \RuntimeException('No member attribute specified');
+            }
+            $this->member = Shape::create(
+                $this->definition['member'],
+                $this->shapeMap
+            );
+        }
+
+        return $this->member;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/MapShape.php

@@ -0,0 +1,54 @@
+<?php
+namespace Aws\Api;
+
+/**
+ * Represents a map shape.
+ */
+class MapShape extends Shape
+{
+    /** @var Shape */
+    private $value;
+
+    /** @var Shape */
+    private $key;
+
+    public function __construct(array $definition, ShapeMap $shapeMap)
+    {
+        $definition['type'] = 'map';
+        parent::__construct($definition, $shapeMap);
+    }
+
+    /**
+     * @return Shape
+     * @throws \RuntimeException if no value is specified
+     */
+    public function getValue()
+    {
+        if (!$this->value) {
+            if (!isset($this->definition['value'])) {
+                throw new \RuntimeException('No value specified');
+            }
+
+            $this->value = Shape::create(
+                $this->definition['value'],
+                $this->shapeMap
+            );
+        }
+
+        return $this->value;
+    }
+
+    /**
+     * @return Shape
+     */
+    public function getKey()
+    {
+        if (!$this->key) {
+            $this->key = isset($this->definition['key'])
+                ? Shape::create($this->definition['key'], $this->shapeMap)
+                : new Shape(['type' => 'string'], $this->shapeMap);
+        }
+
+        return $this->key;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Operation.php

@@ -0,0 +1,158 @@
+<?php
+namespace Aws\Api;
+
+/**
+ * Represents an API operation.
+ */
+class Operation extends AbstractModel
+{
+    private $input;
+    private $output;
+    private $errors;
+    private $staticContextParams = [];
+    private $contextParams;
+    private $operationContextParams = [];
+
+    public function __construct(array $definition, ShapeMap $shapeMap)
+    {
+        $definition['type'] = 'structure';
+
+        if (!isset($definition['http']['method'])) {
+            $definition['http']['method'] = 'POST';
+        }
+
+        if (!isset($definition['http']['requestUri'])) {
+            $definition['http']['requestUri'] = '/';
+        }
+
+        if (isset($definition['staticContextParams'])) {
+            $this->staticContextParams = $definition['staticContextParams'];
+        }
+
+        if (isset($definition['operationContextParams'])) {
+            $this->operationContextParams = $definition['operationContextParams'];
+        }
+
+        parent::__construct($definition, $shapeMap);
+        $this->contextParams = $this->setContextParams();
+    }
+
+    /**
+     * Returns an associative array of the HTTP attribute of the operation:
+     *
+     * - method: HTTP method of the operation
+     * - requestUri: URI of the request (can include URI template placeholders)
+     *
+     * @return array
+     */
+    public function getHttp()
+    {
+        return $this->definition['http'];
+    }
+
+    /**
+     * Get the input shape of the operation.
+     *
+     * @return StructureShape
+     */
+    public function getInput()
+    {
+        if (!$this->input) {
+            if ($input = $this['input']) {
+                $this->input = $this->shapeFor($input);
+            } else {
+                $this->input = new StructureShape([], $this->shapeMap);
+            }
+        }
+
+        return $this->input;
+    }
+
+    /**
+     * Get the output shape of the operation.
+     *
+     * @return StructureShape
+     */
+    public function getOutput()
+    {
+        if (!$this->output) {
+            if ($output = $this['output']) {
+                $this->output = $this->shapeFor($output);
+            } else {
+                $this->output = new StructureShape([], $this->shapeMap);
+            }
+        }
+
+        return $this->output;
+    }
+
+    /**
+     * Get an array of operation error shapes.
+     *
+     * @return Shape[]
+     */
+    public function getErrors()
+    {
+        if ($this->errors === null) {
+            if ($errors = $this['errors']) {
+                foreach ($errors as $key => $error) {
+                    $errors[$key] = $this->shapeFor($error);
+                }
+                $this->errors = $errors;
+            } else {
+                $this->errors = [];
+            }
+        }
+
+        return $this->errors;
+    }
+
+    /**
+     * Gets static modeled static values used for
+     * endpoint resolution.
+     *
+     * @return array
+     */
+    public function getStaticContextParams()
+    {
+        return $this->staticContextParams;
+    }
+
+    /**
+     * Gets definition of modeled dynamic values used
+     * for endpoint resolution
+     *
+     * @return array
+     */
+    public function getContextParams()
+    {
+        return $this->contextParams;
+    }
+
+    /**
+     * Gets definition of modeled dynamic values used
+     * for endpoint resolution
+     *
+     * @return array
+     */
+    public function getOperationContextParams(): array
+    {
+        return $this->operationContextParams;
+    }
+
+    private function setContextParams()
+    {
+        $members = $this->getInput()->getMembers();
+        $contextParams = [];
+
+        foreach($members as $name => $shape) {
+            if (!empty($contextParam = $shape->getContextParam())) {
+                $contextParams[$contextParam['name']] = [
+                    'shape' => $name,
+                    'type' => $shape->getType()
+                ];
+            }
+        }
+        return $contextParams;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/AbstractParser.php

@@ -0,0 +1,46 @@
+<?php
+namespace Aws\Api\Parser;
+
+use Aws\Api\Service;
+use Aws\Api\StructureShape;
+use Aws\CommandInterface;
+use Aws\ResultInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamInterface;
+
+/**
+ * @internal
+ */
+abstract class AbstractParser
+{
+    /** @var \Aws\Api\Service Representation of the service API*/
+    protected $api;
+
+    /** @var callable */
+    protected $parser;
+
+    /**
+     * @param Service $api Service description.
+     */
+    public function __construct(Service $api)
+    {
+        $this->api = $api;
+    }
+
+    /**
+     * @param CommandInterface  $command  Command that was executed.
+     * @param ResponseInterface $response Response that was received.
+     *
+     * @return ResultInterface
+     */
+    abstract public function __invoke(
+        CommandInterface $command,
+        ResponseInterface $response
+    );
+
+    abstract public function parseMemberFromStream(
+        StreamInterface $stream,
+        StructureShape $member,
+        $response
+    );
+}

vendor/aws/aws-sdk-php/src/Api/Parser/AbstractRestParser.php

@@ -0,0 +1,216 @@
+<?php
+namespace Aws\Api\Parser;
+
+use Aws\Api\DateTimeResult;
+use Aws\Api\Shape;
+use Aws\Api\StructureShape;
+use Aws\Result;
+use Aws\CommandInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * @internal
+ */
+abstract class AbstractRestParser extends AbstractParser
+{
+    use PayloadParserTrait;
+
+    /**
+     * Parses a payload from a response.
+     *
+     * @param ResponseInterface $response Response to parse.
+     * @param StructureShape    $member   Member to parse
+     * @param array             $result   Result value
+     *
+     * @return mixed
+     */
+    abstract protected function payload(
+        ResponseInterface $response,
+        StructureShape $member,
+        array &$result
+    );
+
+    public function __invoke(
+        CommandInterface $command,
+        ResponseInterface $response
+    ) {
+        $output = $this->api->getOperation($command->getName())->getOutput();
+        $result = [];
+
+        if ($payload = $output['payload']) {
+            $this->extractPayload($payload, $output, $response, $result);
+        }
+
+        foreach ($output->getMembers() as $name => $member) {
+            switch ($member['location']) {
+                case 'header':
+                    $this->extractHeader($name, $member, $response, $result);
+                    break;
+                case 'headers':
+                    $this->extractHeaders($name, $member, $response, $result);
+                    break;
+                case 'statusCode':
+                    $this->extractStatus($name, $response, $result);
+                    break;
+            }
+        }
+
+        $body = $response->getBody();
+        if (!$payload
+            && (!$body->isSeekable() || $body->getSize())
+            && count($output->getMembers()) > 0
+        ) {
+            // if no payload was found, then parse the contents of the body
+            $this->payload($response, $output, $result);
+        }
+
+        return new Result($result);
+    }
+
+    private function extractPayload(
+        $payload,
+        StructureShape $output,
+        ResponseInterface $response,
+        array &$result
+    ) {
+        $member = $output->getMember($payload);
+        $body = $response->getBody();
+
+        if (!empty($member['eventstream'])) {
+            $result[$payload] = new EventParsingIterator(
+                $body,
+                $member,
+                $this
+            );
+        } elseif ($member instanceof StructureShape) {
+            //Unions must have at least one member set to a non-null value
+            // If the body is empty, we can assume it is unset
+            if (!empty($member['union']) && ($body->isSeekable() && !$body->getSize())) {
+                return;
+            }
+
+            $result[$payload] = [];
+            $this->payload($response, $member, $result[$payload]);
+        } else {
+            // Always set the payload to the body stream, regardless of content
+            $result[$payload] = $body;
+        }
+    }
+
+    /**
+     * Extract a single header from the response into the result.
+     */
+    private function extractHeader(
+        $name,
+        Shape $shape,
+        ResponseInterface $response,
+        &$result
+    ) {
+        $value = $response->getHeaderLine($shape['locationName'] ?: $name);
+        // Empty headers should not be deserialized
+        if ($value === null || $value === '') {
+            return;
+        }
+
+        switch ($shape->getType()) {
+            case 'float':
+            case 'double':
+                $value = match ($value) {
+                    'NaN', 'Infinity', '-Infinity' => $value,
+                    default => (float) $value
+                };
+                break;
+            case 'long':
+            case 'integer':
+                $value = (int) $value;
+                break;
+            case 'boolean':
+                $value = filter_var($value, FILTER_VALIDATE_BOOLEAN);
+                break;
+            case 'blob':
+                $value = base64_decode($value);
+                break;
+            case 'timestamp':
+                try {
+                    $value = DateTimeResult::fromTimestamp(
+                        $value,
+                        !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : null
+                    );
+                    break;
+                } catch (\Exception $e) {
+                    // If the value cannot be parsed, then do not add it to the
+                    // output structure.
+                    return;
+                }
+            case 'string':
+                try {
+                    if ($shape['jsonvalue']) {
+                        $value = $this->parseJson(base64_decode($value), $response);
+                    }
+
+                    // If value is not set, do not add to output structure.
+                    if (!isset($value)) {
+                        return;
+                    }
+                    break;
+                } catch (\Exception $e) {
+                    //If the value cannot be parsed, then do not add it to the
+                    //output structure.
+                    return;
+                }
+            case 'list':
+                $listMember = $shape->getMember();
+                $type = $listMember->getType();
+
+                // Only boolean lists require special handling
+                // other types can be returned as-is
+                if ($type !== 'boolean') {
+                    break;
+                }
+
+                $items = array_map('trim', explode(',', $value));
+                $value = array_map(
+                    static fn($item) => filter_var($item, FILTER_VALIDATE_BOOLEAN),
+                    $items
+                );
+
+                break;
+        }
+
+        $result[$name] = $value;
+    }
+
+    /**
+     * Extract a map of headers with an optional prefix from the response.
+     */
+    private function extractHeaders(
+        $name,
+        Shape $shape,
+        ResponseInterface $response,
+        &$result
+    ) {
+        // Check if the headers are prefixed by a location name
+        $result[$name] = [];
+        $prefix = $shape['locationName'];
+        $prefixLen = $prefix !== null ? strlen($prefix) : 0;
+
+        foreach ($response->getHeaders() as $k => $values) {
+            if (!$prefixLen) {
+                $result[$name][$k] = implode(', ', $values);
+            } elseif (stripos($k, $prefix) === 0) {
+                $result[$name][substr($k, $prefixLen)] = implode(', ', $values);
+            }
+        }
+    }
+
+    /**
+     * Places the status code of the response into the result array.
+     */
+    private function extractStatus(
+        $name,
+        ResponseInterface $response,
+        array &$result
+    ) {
+        $result[$name] = (int) $response->getStatusCode();
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/Crc32ValidatingParser.php

@@ -0,0 +1,54 @@
+<?php
+namespace Aws\Api\Parser;
+
+use Aws\Api\StructureShape;
+use Aws\CommandInterface;
+use Aws\Exception\AwsException;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamInterface;
+use GuzzleHttp\Psr7;
+
+/**
+ * @internal Decorates a parser and validates the x-amz-crc32 header.
+ */
+class Crc32ValidatingParser extends AbstractParser
+{
+    /**
+     * @param callable $parser Parser to wrap.
+     */
+    public function __construct(callable $parser)
+    {
+        $this->parser = $parser;
+    }
+
+    public function __invoke(
+        CommandInterface $command,
+        ResponseInterface $response
+    ) {
+        if ($expected = $response->getHeaderLine('x-amz-crc32')) {
+            $hash = hexdec(Psr7\Utils::hash($response->getBody(), 'crc32b'));
+            if ($expected != $hash) {
+                throw new AwsException(
+                    "crc32 mismatch. Expected {$expected}, found {$hash}.",
+                    $command,
+                    [
+                        'code'             => 'ClientChecksumMismatch',
+                        'connection_error' => true,
+                        'response'         => $response
+                    ]
+                );
+            }
+        }
+
+        $fn = $this->parser;
+        return $fn($command, $response);
+    }
+
+    public function parseMemberFromStream(
+        StreamInterface $stream,
+        StructureShape $member,
+        $response
+    ) {
+        return $this->parser->parseMemberFromStream($stream, $member, $response);
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/DecodingEventStreamIterator.php

@@ -0,0 +1,347 @@
+<?php
+
+namespace Aws\Api\Parser;
+
+use \Iterator;
+use Aws\Api\DateTimeResult;
+use GuzzleHttp\Psr7;
+use Psr\Http\Message\StreamInterface;
+use Aws\Api\Parser\Exception\ParserException;
+
+/**
+ * @internal Implements a decoder for a binary encoded event stream that will
+ * decode, validate, and provide individual events from the stream.
+ */
+class DecodingEventStreamIterator implements Iterator
+{
+    const HEADERS = 'headers';
+    const PAYLOAD = 'payload';
+
+    const LENGTH_TOTAL = 'total_length';
+    const LENGTH_HEADERS = 'headers_length';
+
+    const CRC_PRELUDE = 'prelude_crc';
+
+    const BYTES_PRELUDE = 12;
+    const BYTES_TRAILING = 4;
+
+    private static $preludeFormat = [
+        self::LENGTH_TOTAL => 'decodeUint32',
+        self::LENGTH_HEADERS => 'decodeUint32',
+        self::CRC_PRELUDE => 'decodeUint32',
+    ];
+
+    private static $lengthFormatMap = [
+        1 => 'decodeUint8',
+        2 => 'decodeUint16',
+        4 => 'decodeUint32',
+        8 => 'decodeUint64',
+    ];
+
+    private static $headerTypeMap = [
+        0 => 'decodeBooleanTrue',
+        1 => 'decodeBooleanFalse',
+        2 => 'decodeInt8',
+        3 => 'decodeInt16',
+        4 => 'decodeInt32',
+        5 => 'decodeInt64',
+        6 => 'decodeBytes',
+        7 => 'decodeString',
+        8 => 'decodeTimestamp',
+        9 => 'decodeUuid',
+    ];
+
+    /** @var StreamInterface Stream of eventstream shape to parse. */
+    protected $stream;
+
+    /** @var array Currently parsed event. */
+    protected $currentEvent;
+
+    /** @var int Current in-order event key. */
+    protected $key;
+
+    /** @var resource|\HashContext CRC32 hash context for event validation */
+    protected $hashContext;
+
+    /** @var int $currentPosition */
+    protected $currentPosition;
+
+    /**
+     * DecodingEventStreamIterator constructor.
+     *
+     * @param StreamInterface $stream
+     */
+    public function __construct(StreamInterface $stream)
+    {
+        $this->stream = $stream;
+        $this->rewind();
+    }
+
+    protected function parseHeaders($headerBytes)
+    {
+        $headers = [];
+        $bytesRead = 0;
+
+        while ($bytesRead < $headerBytes) {
+            list($key, $numBytes) = $this->decodeString(1);
+            $bytesRead += $numBytes;
+
+            list($type, $numBytes) = $this->decodeUint8();
+            $bytesRead += $numBytes;
+
+            $f = self::$headerTypeMap[$type];
+            list($value, $numBytes) = $this->{$f}();
+            $bytesRead += $numBytes;
+
+            if (isset($headers[$key])) {
+                throw new ParserException('Duplicate key in event headers.');
+            }
+            $headers[$key] = $value;
+        }
+
+        return [$headers, $bytesRead];
+    }
+
+    protected function parsePrelude()
+    {
+        $prelude = [];
+        $bytesRead = 0;
+
+        $calculatedCrc = null;
+        foreach (self::$preludeFormat as $key => $decodeFunction) {
+            if ($key === self::CRC_PRELUDE) {
+                $hashCopy = hash_copy($this->hashContext);
+                $calculatedCrc = hash_final($this->hashContext, true);
+                $this->hashContext = $hashCopy;
+            }
+            list($value, $numBytes) = $this->{$decodeFunction}();
+            $bytesRead += $numBytes;
+
+            $prelude[$key] = $value;
+        }
+
+        if (unpack('N', $calculatedCrc)[1] !== $prelude[self::CRC_PRELUDE]) {
+            throw new ParserException('Prelude checksum mismatch.');
+        }
+
+        return [$prelude, $bytesRead];
+    }
+
+    /**
+     * This method decodes an event from the stream.
+     *
+     * @return array
+     */
+    protected function parseEvent()
+    {
+        $event = [];
+
+        if ($this->stream->tell() < $this->stream->getSize()) {
+            $this->hashContext = hash_init('crc32b');
+
+            $bytesLeft = $this->stream->getSize() - $this->stream->tell();
+            list($prelude, $numBytes) = $this->parsePrelude();
+            if ($prelude[self::LENGTH_TOTAL] > $bytesLeft) {
+                throw new ParserException('Message length too long.');
+            }
+            $bytesLeft -= $numBytes;
+
+            if ($prelude[self::LENGTH_HEADERS] > $bytesLeft) {
+                throw new ParserException('Headers length too long.');
+            }
+
+            list(
+                $event[self::HEADERS],
+                $numBytes
+            ) = $this->parseHeaders($prelude[self::LENGTH_HEADERS]);
+
+            $event[self::PAYLOAD] = Psr7\Utils::streamFor(
+                $this->readAndHashBytes(
+                    $prelude[self::LENGTH_TOTAL] - self::BYTES_PRELUDE
+                    - $numBytes - self::BYTES_TRAILING
+                )
+            );
+
+            $calculatedCrc = hash_final($this->hashContext, true);
+            $messageCrc = $this->stream->read(4);
+            if ($calculatedCrc !== $messageCrc) {
+                throw new ParserException('Message checksum mismatch.');
+            }
+        }
+
+        return $event;
+    }
+
+    // Iterator Functionality
+
+    /**
+     * @return array
+     */
+    #[\ReturnTypeWillChange]
+    public function current()
+    {
+        return $this->currentEvent;
+    }
+
+    /**
+     * @return int
+     */
+    #[\ReturnTypeWillChange]
+    public function key()
+    {
+        return $this->key;
+    }
+
+    /**
+     * @return void
+     */
+    #[\ReturnTypeWillChange]
+    public function next()
+    {
+        $this->currentPosition = $this->stream->tell();
+        if ($this->valid()) {
+            $this->key++;
+            $this->currentEvent = $this->parseEvent();
+        }
+    }
+
+    /**
+     * @return void
+     */
+    #[\ReturnTypeWillChange]
+    public function rewind()
+    {
+        $this->stream->rewind();
+        $this->key = 0;
+        $this->currentPosition = 0;
+        $this->currentEvent = $this->parseEvent();
+    }
+
+    /**
+     * @return bool
+     */
+    #[\ReturnTypeWillChange]
+    public function valid()
+    {
+        return $this->currentPosition < $this->stream->getSize();
+    }
+
+    // Decoding Utilities
+
+    protected function readAndHashBytes($num)
+    {
+        $bytes = $this->stream->read($num);
+        hash_update($this->hashContext, $bytes);
+        return $bytes;
+    }
+
+    private function decodeBooleanTrue()
+    {
+        return [true, 0];
+    }
+
+    private function decodeBooleanFalse()
+    {
+        return [false, 0];
+    }
+
+    private function uintToInt($val, $size)
+    {
+        $signedCap = pow(2, $size - 1);
+        if ($val > $signedCap) {
+            $val -= (2 * $signedCap);
+        }
+        return $val;
+    }
+
+    private function decodeInt8()
+    {
+        $val = (int)unpack('C', $this->readAndHashBytes(1))[1];
+        return [$this->uintToInt($val, 8), 1];
+    }
+
+    private function decodeUint8()
+    {
+        return [unpack('C', $this->readAndHashBytes(1))[1], 1];
+    }
+
+    private function decodeInt16()
+    {
+        $val = (int)unpack('n', $this->readAndHashBytes(2))[1];
+        return [$this->uintToInt($val, 16), 2];
+    }
+
+    private function decodeUint16()
+    {
+        return [unpack('n', $this->readAndHashBytes(2))[1], 2];
+    }
+
+    private function decodeInt32()
+    {
+        $val = (int)unpack('N', $this->readAndHashBytes(4))[1];
+        return [$this->uintToInt($val, 32), 4];
+    }
+
+    private function decodeUint32()
+    {
+        return [unpack('N', $this->readAndHashBytes(4))[1], 4];
+    }
+
+    private function decodeInt64()
+    {
+        $val = $this->unpackInt64($this->readAndHashBytes(8))[1];
+        return [$this->uintToInt($val, 64), 8];
+    }
+
+    private function decodeUint64()
+    {
+        return [$this->unpackInt64($this->readAndHashBytes(8))[1], 8];
+    }
+
+    private function unpackInt64($bytes)
+    {
+        return unpack('J', $bytes);
+    }
+
+    private function decodeBytes($lengthBytes=2)
+    {
+        if (!isset(self::$lengthFormatMap[$lengthBytes])) {
+            throw new ParserException('Undefined variable length format.');
+        }
+        $f = self::$lengthFormatMap[$lengthBytes];
+        list($len, $bytes) = $this->{$f}();
+        return [$this->readAndHashBytes($len), $len + $bytes];
+    }
+
+    private function decodeString($lengthBytes=2)
+    {
+        if (!isset(self::$lengthFormatMap[$lengthBytes])) {
+            throw new ParserException('Undefined variable length format.');
+        }
+        $f = self::$lengthFormatMap[$lengthBytes];
+        list($len, $bytes) = $this->{$f}();
+        return [$this->readAndHashBytes($len), $len + $bytes];
+    }
+
+    private function decodeTimestamp()
+    {
+        list($val, $bytes) = $this->decodeInt64();
+        return [
+            DateTimeResult::createFromFormat('U.u', $val / 1000),
+            $bytes
+        ];
+    }
+
+    private function decodeUuid()
+    {
+        $val = unpack('H32', $this->readAndHashBytes(16))[1];
+        return [
+            substr($val, 0, 8) . '-'
+            . substr($val, 8, 4) . '-'
+            . substr($val, 12, 4) . '-'
+            . substr($val, 16, 4) . '-'
+            . substr($val, 20, 12),
+            16
+        ];
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/EventParsingIterator.php

@@ -0,0 +1,211 @@
+<?php
+
+namespace Aws\Api\Parser;
+
+use \Iterator;
+use Aws\Exception\EventStreamDataException;
+use Aws\Api\Parser\Exception\ParserException;
+use Aws\Api\StructureShape;
+use Psr\Http\Message\StreamInterface;
+
+/**
+ * @internal Implements a decoder for a binary encoded event stream that will
+ * decode, validate, and provide individual events from the stream.
+ */
+class EventParsingIterator implements Iterator
+{
+    /** @var StreamInterface */
+    private $decodingIterator;
+
+    /** @var StructureShape */
+    private $shape;
+
+    /** @var AbstractParser */
+    private $parser;
+
+    public function __construct(
+        StreamInterface $stream,
+        StructureShape $shape,
+        AbstractParser $parser
+    ) {
+        $this->decodingIterator = $this->chooseDecodingIterator($stream);
+        $this->shape = $shape;
+        $this->parser = $parser;
+    }
+
+    /**
+     * This method choose a decoding iterator implementation based on if the stream
+     * is seekable or not.
+     *
+     * @param $stream
+     *
+     * @return Iterator
+     */
+    private function chooseDecodingIterator($stream)
+    {
+        if ($stream->isSeekable()) {
+            return new DecodingEventStreamIterator($stream);
+        } else {
+            return new NonSeekableStreamDecodingEventStreamIterator($stream);
+        }
+    }
+
+    /**
+     * @return mixed
+     */
+    #[\ReturnTypeWillChange]
+    public function current()
+    {
+        return $this->parseEvent($this->decodingIterator->current());
+    }
+
+    /**
+     * @return mixed
+     */
+    #[\ReturnTypeWillChange]
+    public function key()
+    {
+        return $this->decodingIterator->key();
+    }
+
+    /**
+     * @return void
+     */
+    #[\ReturnTypeWillChange]
+    public function next()
+    {
+        $this->decodingIterator->next();
+    }
+
+    /**
+     * @return void
+     */
+    #[\ReturnTypeWillChange]
+    public function rewind()
+    {
+        $this->decodingIterator->rewind();
+    }
+
+    /**
+     * @return bool
+     */
+    #[\ReturnTypeWillChange]
+    public function valid()
+    {
+        return $this->decodingIterator->valid();
+    }
+
+    private function parseEvent(array $event)
+    {
+        if (!empty($event['headers'][':message-type'])) {
+            if ($event['headers'][':message-type'] === 'error') {
+                return $this->parseError($event);
+            }
+
+            if ($event['headers'][':message-type'] === 'exception') {
+                return $this->parseException($event);
+            }
+
+            if ($event['headers'][':message-type'] !== 'event') {
+                throw new ParserException('Failed to parse unknown message type.');
+            }
+        }
+
+        $eventType = $event['headers'][':event-type'] ?? null;
+        if (empty($eventType)) {
+            throw new ParserException('Failed to parse without event type.');
+        }
+
+        $eventPayload = $event['payload'];
+        if ($eventType === 'initial-response') {
+            return $this->parseInitialResponseEvent($eventPayload);
+        }
+
+        $eventShape = $this->shape->getMember($eventType);
+
+        return [
+            $eventType => array_merge(
+                $this->parseEventHeaders($event['headers'], $eventShape),
+                $this->parseEventPayload($eventPayload, $eventShape)
+            )
+        ];
+    }
+
+    /**
+     * @param $headers
+     * @param $eventShape
+     *
+     * @return array
+     */
+    private function parseEventHeaders($headers, $eventShape): array
+    {
+        $parsedHeaders = [];
+        foreach ($eventShape->getMembers() as $memberName => $memberProps) {
+            if (isset($memberProps['eventheader'])) {
+                $parsedHeaders[$memberName] = $headers[$memberName];
+            }
+        }
+
+        return $parsedHeaders;
+    }
+
+    /**
+     * @param $payload
+     * @param $eventShape
+     *
+     * @return array
+     */
+    private function parseEventPayload($payload, $eventShape): array
+    {
+        $parsedPayload = [];
+        foreach ($eventShape->getMembers() as $memberName => $memberProps) {
+            $memberShape = $eventShape->getMember($memberName);
+            if (isset($memberProps['eventpayload'])) {
+                if ($memberShape->getType() === 'blob') {
+                    $parsedPayload[$memberName] = $payload;
+                } else {
+                    $parsedPayload[$memberName] = $this->parser->parseMemberFromStream(
+                        $payload,
+                        $memberShape,
+                        null
+                    );
+                }
+
+                break;
+            }
+        }
+
+        if (empty($parsedPayload) && !empty($payload->getContents())) {
+            /**
+             * If we did not find a member with an eventpayload trait, then we should deserialize the payload
+             * using the event's shape.
+             */
+            $parsedPayload = $this->parser->parseMemberFromStream($payload, $eventShape, null);
+        }
+
+        return $parsedPayload;
+    }
+
+    private function parseError(array $event)
+    {
+        throw new EventStreamDataException(
+            $event['headers'][':error-code'],
+            $event['headers'][':error-message']
+        );
+    }
+
+    private function parseException(array $event) {
+        $payload = $event['payload']?->getContents();
+        $parsedPayload = json_decode($payload, true);
+
+        throw new EventStreamDataException(
+            $event['headers'][':exception-type'] ?? 'Unknown',
+            $parsedPayload['message'] ?? $payload,
+        );
+    }
+
+    private function parseInitialResponseEvent($payload): array
+    {
+        return ['initial-response' => json_decode($payload, true)];
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/Exception/ParserException.php

@@ -0,0 +1,56 @@
+<?php
+namespace Aws\Api\Parser\Exception;
+
+use Aws\HasMonitoringEventsTrait;
+use Aws\MonitoringEventsInterface;
+use Aws\ResponseContainerInterface;
+use Psr\Http\Message\ResponseInterface;
+
+class ParserException extends \RuntimeException implements
+    MonitoringEventsInterface,
+    ResponseContainerInterface
+{
+    use HasMonitoringEventsTrait;
+
+    private $errorCode;
+    private $requestId;
+    private $response;
+
+    public function __construct($message = '', $code = 0, $previous = null, array $context = [])
+    {
+        $this->errorCode = isset($context['error_code']) ? $context['error_code'] : null;
+        $this->requestId = isset($context['request_id']) ? $context['request_id'] : null;
+        $this->response = isset($context['response']) ? $context['response'] : null;
+        parent::__construct($message, $code, $previous);
+    }
+
+    /**
+     * Get the error code, if any.
+     *
+     * @return string|null
+     */
+    public function getErrorCode()
+    {
+        return $this->errorCode;
+    }
+
+    /**
+     * Get the request ID, if any.
+     *
+     * @return string|null
+     */
+    public function getRequestId()
+    {
+        return $this->requestId;
+    }
+
+    /**
+     * Get the received HTTP response if any.
+     *
+     * @return ResponseInterface|null
+     */
+    public function getResponse()
+    {
+        return $this->response;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/JsonParser.php

@@ -0,0 +1,74 @@
+<?php
+namespace Aws\Api\Parser;
+
+use Aws\Api\DateTimeResult;
+use Aws\Api\Shape;
+
+/**
+ * @internal Implements standard JSON parsing.
+ */
+class JsonParser
+{
+    public function parse(Shape $shape, $value)
+    {
+        if ($value === null) {
+            return $value;
+        }
+
+        switch ($shape['type']) {
+            case 'structure':
+                if (isset($shape['document']) && $shape['document']) {
+                    return $value;
+                }
+                $target = [];
+                foreach ($shape->getMembers() as $name => $member) {
+                    $locationName = $member['locationName'] ?: $name;
+                    if (isset($value[$locationName])) {
+                        $target[$name] = $this->parse($member, $value[$locationName]);
+                    }
+                }
+                if (isset($shape['union'])
+                    && $shape['union']
+                    && is_array($value)
+                    && empty($target)
+                ) {
+                    foreach ($value as $key => $val) {
+                        $target['Unknown'][$key] = $val;
+                    }
+                }
+                return $target;
+
+            case 'list':
+                $member = $shape->getMember();
+                $target = [];
+                foreach ($value as $v) {
+                    $target[] = $this->parse($member, $v);
+                }
+                return $target;
+
+            case 'map':
+                $values = $shape->getValue();
+                $target = [];
+                foreach ($value as $k => $v) {
+                    // null map values should not be deserialized
+                    if (!is_null($v)) {
+                        $target[$k] = $this->parse($values, $v);
+                    }
+                }
+                return $target;
+
+            case 'timestamp':
+                return DateTimeResult::fromTimestamp(
+                    $value,
+                    !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : null
+                );
+
+            case 'blob':
+                return base64_decode($value);
+
+            default:
+                return $value;
+        }
+    }
+}
+

vendor/aws/aws-sdk-php/src/Api/Parser/JsonRpcParser.php

@@ -0,0 +1,82 @@
+<?php
+namespace Aws\Api\Parser;
+
+use Aws\Api\Operation;
+use Aws\Api\StructureShape;
+use Aws\Api\Service;
+use Aws\Result;
+use Aws\CommandInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamInterface;
+
+/**
+ * @internal Implements JSON-RPC parsing (e.g., DynamoDB)
+ */
+class JsonRpcParser extends AbstractParser
+{
+    use PayloadParserTrait;
+
+    /**
+     * @param Service    $api    Service description
+     * @param JsonParser $parser JSON body builder
+     */
+    public function __construct(Service $api, ?JsonParser $parser = null)
+    {
+        parent::__construct($api);
+        $this->parser = $parser ?: new JsonParser();
+    }
+
+    public function __invoke(
+        CommandInterface $command,
+        ResponseInterface $response
+    ) {
+        $operation = $this->api->getOperation($command->getName());
+
+        return $this->parseResponse($response, $operation);
+    }
+
+    /**
+     * This method parses a response based on JSON RPC protocol.
+     *
+     * @param ResponseInterface $response the response to parse.
+     * @param Operation $operation the operation which holds information for
+     *        parsing the response.
+     *
+     * @return Result
+     */
+    private function parseResponse(ResponseInterface $response, Operation $operation)
+    {
+        if (null === $operation['output']) {
+            return new Result([]);
+        }
+
+        $outputShape = $operation->getOutput();
+        foreach ($outputShape->getMembers() as $memberName => $memberProps) {
+            if (!empty($memberProps['eventstream'])) {
+                return new Result([
+                    $memberName => new EventParsingIterator(
+                        $response->getBody(),
+                        $outputShape->getMember($memberName),
+                        $this
+                    )
+                ]);
+            }
+        }
+
+        $result = $this->parseMemberFromStream(
+                $response->getBody(),
+                $operation->getOutput(),
+                $response
+            );
+
+        return new Result(is_null($result) ? [] : $result);
+    }
+
+    public function parseMemberFromStream(
+        StreamInterface $stream,
+        StructureShape $member,
+        $response
+    ) {
+        return $this->parser->parse($member, $this->parseJson($stream, $response));
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/MetadataParserTrait.php

@@ -0,0 +1,95 @@
+<?php
+namespace Aws\Api\Parser;
+
+use Aws\Api\DateTimeResult;
+use Aws\Api\Shape;
+use Psr\Http\Message\ResponseInterface;
+
+trait MetadataParserTrait
+{
+    /**
+     * Extract a single header from the response into the result.
+     */
+    protected function extractHeader(
+        $name,
+        Shape $shape,
+        ResponseInterface $response,
+        &$result
+    ) {
+        $value = $response->getHeaderLine($shape['locationName'] ?: $name);
+        // Empty values should not be deserialized
+        if ($value === null || $value === '') {
+            return;
+        }
+
+        switch ($shape->getType()) {
+            case 'float':
+            case 'double':
+                $value = (float) $value;
+                break;
+            case 'long':
+            case 'integer':
+                $value = (int) $value;
+                break;
+            case 'boolean':
+                $value = filter_var($value, FILTER_VALIDATE_BOOLEAN);
+                break;
+            case 'blob':
+                $value = base64_decode($value);
+                break;
+            case 'timestamp':
+                try {
+                    $value = DateTimeResult::fromTimestamp(
+                        $value,
+                        !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : null
+                    );
+                    break;
+                } catch (\Exception $e) {
+                    // If the value cannot be parsed, then do not add it to the
+                    // output structure.
+                    return;
+                }
+            case 'string':
+                if ($shape['jsonvalue']) {
+                    $value = $this->parseJson(base64_decode($value), $response);
+                }
+                break;
+        }
+
+        $result[$name] = $value;
+    }
+
+    /**
+     * Extract a map of headers with an optional prefix from the response.
+     */
+    protected function extractHeaders(
+        $name,
+        Shape $shape,
+        ResponseInterface $response,
+        &$result
+    ) {
+        // Check if the headers are prefixed by a location name
+        $result[$name] = [];
+        $prefix = $shape['locationName'];
+        $prefixLen = strlen($prefix);
+
+        foreach ($response->getHeaders() as $k => $values) {
+            if (!$prefixLen) {
+                $result[$name][$k] = implode(', ', $values);
+            } elseif (stripos($k, $prefix) === 0) {
+                $result[$name][substr($k, $prefixLen)] = implode(', ', $values);
+            }
+        }
+    }
+
+    /**
+     * Places the status code of the response into the result array.
+     */
+    protected function extractStatus(
+        $name,
+        ResponseInterface $response,
+        array &$result
+    ) {
+        $result[$name] = (int) $response->getStatusCode();
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/NonSeekableStreamDecodingEventStreamIterator.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace Aws\Api\Parser;
+
+use GuzzleHttp\Psr7;
+use Psr\Http\Message\StreamInterface;
+use Aws\Api\Parser\Exception\ParserException;
+
+/**
+ * @inheritDoc
+ */
+class NonSeekableStreamDecodingEventStreamIterator extends DecodingEventStreamIterator
+{
+    /** @var array $tempBuffer */
+    private $tempBuffer;
+
+    /**
+     * NonSeekableStreamDecodingEventStreamIterator constructor.
+     *
+     * @param StreamInterface $stream
+     */
+    public function __construct(StreamInterface $stream)
+    {
+        $this->stream = $stream;
+        if ($this->stream->isSeekable()) {
+            throw new \InvalidArgumentException('The stream provided must be not seekable.');
+        }
+
+        $this->tempBuffer = [];
+    }
+
+    /**
+     * @inheritDoc
+     *
+     * @return array
+     */
+    protected function parseEvent(): array
+    {
+        $event = [];
+        $this->hashContext = hash_init('crc32b');
+        $prelude = $this->parsePrelude()[0];
+        list(
+            $event[self::HEADERS],
+            $numBytes
+        ) = $this->parseHeaders($prelude[self::LENGTH_HEADERS]);
+        $event[self::PAYLOAD] = Psr7\Utils::streamFor(
+            $this->readAndHashBytes(
+                $prelude[self::LENGTH_TOTAL] - self::BYTES_PRELUDE
+                - $numBytes - self::BYTES_TRAILING
+            )
+        );
+        $calculatedCrc = hash_final($this->hashContext, true);
+        $messageCrc = $this->stream->read(4);
+        if ($calculatedCrc !== $messageCrc) {
+            throw new ParserException('Message checksum mismatch.');
+        }
+
+        return $event;
+    }
+
+    protected function readAndHashBytes($num): string
+    {
+        $bytes = '';
+        while (!empty($this->tempBuffer) && $num > 0) {
+            $byte = array_shift($this->tempBuffer);
+            $bytes .= $byte;
+            $num = $num - 1;
+        }
+
+        $bytes = $bytes . $this->stream->read($num);
+        hash_update($this->hashContext, $bytes);
+
+        return $bytes;
+    }
+
+    // Iterator Functionality
+
+    #[\ReturnTypeWillChange]
+    public function rewind()
+    {
+        $this->currentEvent = $this->parseEvent();
+    }
+
+    public function next()
+    {
+        $this->tempBuffer[] = $this->stream->read(1);
+        if ($this->valid()) {
+            $this->key++;
+            $this->currentEvent = $this->parseEvent();
+        }
+    }
+
+    /**
+     * @return bool
+     */
+    #[\ReturnTypeWillChange]
+    public function valid()
+    {
+        return !$this->stream->eof();
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/PayloadParserTrait.php

@@ -0,0 +1,61 @@
+<?php
+namespace Aws\Api\Parser;
+
+use Aws\Api\Parser\Exception\ParserException;
+use Psr\Http\Message\ResponseInterface;
+
+trait PayloadParserTrait
+{
+    /**
+     * @param string $json
+     *
+     * @throws ParserException
+     *
+     * @return array
+     */
+    private function parseJson($json, $response)
+    {
+        $jsonPayload = json_decode($json, true);
+
+        if (JSON_ERROR_NONE !== json_last_error()) {
+            throw new ParserException(
+                'Error parsing JSON: ' . json_last_error_msg(),
+                0,
+                null,
+                ['response' => $response]
+            );
+        }
+
+        return $jsonPayload;
+    }
+
+    /**
+     * @param string $xml
+     *
+     * @throws ParserException
+     *
+     * @return \SimpleXMLElement
+     */
+    protected function parseXml($xml, $response)
+    {
+        $priorSetting = libxml_use_internal_errors(true);
+        try {
+            libxml_clear_errors();
+            $xmlPayload = new \SimpleXMLElement($xml);
+            if ($error = libxml_get_last_error()) {
+                throw new \RuntimeException($error->message);
+            }
+        } catch (\Exception $e) {
+            throw new ParserException(
+                "Error parsing XML: {$e->getMessage()}",
+                0,
+                $e,
+                ['response' => $response]
+            );
+        } finally {
+            libxml_use_internal_errors($priorSetting);
+        }
+
+        return $xmlPayload;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/QueryParser.php

@@ -0,0 +1,68 @@
+<?php
+namespace Aws\Api\Parser;
+
+use Aws\Api\Service;
+use Aws\Api\StructureShape;
+use Aws\Result;
+use Aws\CommandInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamInterface;
+
+/**
+ * @internal Parses query (XML) responses (e.g., EC2, SQS, and many others)
+ */
+class QueryParser extends AbstractParser
+{
+    use PayloadParserTrait;
+
+    /** @var bool */
+    private $honorResultWrapper;
+
+    /**
+     * @param Service   $api                Service description
+     * @param XmlParser $xmlParser          Optional XML parser
+     * @param bool      $honorResultWrapper Set to false to disable the peeling
+     *                                      back of result wrappers from the
+     *                                      output structure.
+     */
+    public function __construct(
+        Service $api,
+        ?XmlParser $xmlParser = null,
+        $honorResultWrapper = true
+    ) {
+        parent::__construct($api);
+        $this->parser = $xmlParser ?: new XmlParser();
+        $this->honorResultWrapper = $honorResultWrapper;
+    }
+
+    public function __invoke(
+        CommandInterface $command,
+        ResponseInterface $response
+    ) {
+        $output = $this->api->getOperation($command->getName())->getOutput();
+        $body = $response->getBody();
+        $xml = !$body->isSeekable() || $body->getSize()
+            ? $this->parseXml($body, $response)
+            : null;
+
+        // Empty request bodies should not be deserialized.
+        if (is_null($xml)) {
+            return new Result();
+        }
+
+        if ($this->honorResultWrapper && $output['resultWrapper']) {
+            $xml = $xml->{$output['resultWrapper']};
+        }
+
+        return new Result($this->parser->parse($output, $xml));
+    }
+
+    public function parseMemberFromStream(
+        StreamInterface $stream,
+        StructureShape $member,
+        $response
+    ) {
+        $xml = $this->parseXml($stream, $response);
+        return $this->parser->parse($member, $xml);
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/RestJsonParser.php

@@ -0,0 +1,64 @@
+<?php
+namespace Aws\Api\Parser;
+
+use Aws\Api\Service;
+use Aws\Api\StructureShape;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamInterface;
+
+/**
+ * @internal Implements REST-JSON parsing (e.g., Glacier, Elastic Transcoder)
+ */
+class RestJsonParser extends AbstractRestParser
+{
+    use PayloadParserTrait;
+
+    /**
+     * @param Service    $api    Service description
+     * @param JsonParser $parser JSON body builder
+     */
+    public function __construct(Service $api, ?JsonParser $parser = null)
+    {
+        parent::__construct($api);
+        $this->parser = $parser ?: new JsonParser();
+    }
+
+    protected function payload(
+        ResponseInterface $response,
+        StructureShape $member,
+        array &$result
+    ) {
+        $responseBody = (string) $response->getBody();
+
+        // Parse JSON if we have content
+        $parsedJson = null;
+        if (!empty($responseBody)) {
+            $parsedJson = $this->parseJson($responseBody, $response);
+        } else {
+            // An empty response body should be deserialized as null
+            $result = $parsedJson;
+            return;
+        }
+
+        $parsedBody = $this->parser->parse($member, $parsedJson);
+        if (is_string($parsedBody) && $member['document']) {
+            // Document types can be strings: replace entire result
+            $result = $parsedBody;
+        } else {
+            // Merge array/object results into existing result
+            $result = array_merge($result, (array) $parsedBody);
+        }
+    }
+
+    public function parseMemberFromStream(
+        StreamInterface $stream,
+        StructureShape $member,
+        $response
+    ) {
+        $jsonBody = $this->parseJson($stream, $response);
+        if ($jsonBody) {
+            return $this->parser->parse($member, $jsonBody);
+        }
+        return [];
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/RestXmlParser.php

@@ -0,0 +1,42 @@
+<?php
+namespace Aws\Api\Parser;
+
+use Aws\Api\StructureShape;
+use Aws\Api\Service;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamInterface;
+
+/**
+ * @internal Implements REST-XML parsing (e.g., S3, CloudFront, etc...)
+ */
+class RestXmlParser extends AbstractRestParser
+{
+    use PayloadParserTrait;
+
+    /**
+     * @param Service   $api    Service description
+     * @param XmlParser $parser XML body parser
+     */
+    public function __construct(Service $api, ?XmlParser $parser = null)
+    {
+        parent::__construct($api);
+        $this->parser = $parser ?: new XmlParser();
+    }
+
+    protected function payload(
+        ResponseInterface $response,
+        StructureShape $member,
+        array &$result
+    ) {
+        $result += $this->parseMemberFromStream($response->getBody(), $member, $response);
+    }
+
+    public function parseMemberFromStream(
+        StreamInterface $stream,
+        StructureShape $member,
+        $response
+    ) {
+        $xml = $this->parseXml($stream, $response);
+        return $this->parser->parse($member, $xml);
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Parser/XmlParser.php

@@ -0,0 +1,183 @@
+<?php
+namespace Aws\Api\Parser;
+
+use Aws\Api\DateTimeResult;
+use Aws\Api\ListShape;
+use Aws\Api\MapShape;
+use Aws\Api\Parser\Exception\ParserException;
+use Aws\Api\Shape;
+use Aws\Api\StructureShape;
+
+/**
+ * @internal Implements standard XML parsing for REST-XML and Query protocols.
+ */
+class XmlParser
+{
+    public function parse(StructureShape $shape, \SimpleXMLElement $value)
+    {
+        return $this->dispatch($shape, $value);
+    }
+
+    private function dispatch($shape, \SimpleXMLElement $value)
+    {
+        static $methods = [
+            'structure' => 'parse_structure',
+            'list'      => 'parse_list',
+            'map'       => 'parse_map',
+            'blob'      => 'parse_blob',
+            'boolean'   => 'parse_boolean',
+            'integer'   => 'parse_integer',
+            'float'     => 'parse_float',
+            'double'    => 'parse_float',
+            'timestamp' => 'parse_timestamp',
+        ];
+
+        $type = $shape['type'];
+        if (isset($methods[$type])) {
+            return $this->{$methods[$type]}($shape, $value);
+        }
+
+        return (string) $value;
+    }
+
+    private function parse_structure(
+        StructureShape $shape,
+        \SimpleXMLElement $value
+    ) {
+        $target = [];
+
+        foreach ($shape->getMembers() as $name => $member) {
+            // Extract the name of the XML node
+            $node = $this->memberKey($member, $name);
+            if (isset($value->{$node})) {
+                $target[$name] = $this->dispatch($member, $value->{$node});
+            } else {
+                $memberShape = $shape->getMember($name);
+                if (!empty($memberShape['xmlAttribute'])) {
+                    $target[$name] = $this->parse_xml_attribute(
+                        $shape,
+                        $memberShape,
+                        $value
+                    );
+                }
+            }
+        }
+        if (isset($shape['union'])
+            && $shape['union']
+            && empty($target)
+        ) {
+            foreach ($value as $key => $val) {
+                $name = $val->children()->getName();
+                $target['Unknown'][$name] = $val->$name;
+            }
+        }
+        return $target;
+    }
+
+    private function memberKey(Shape $shape, $name)
+    {
+        // Check if locationName came from shape definition
+        if ($shape instanceof StructureShape && isset($shape['locationName'])) {
+            $originalDef = $shape->getOriginalDefinition($shape->getName());
+
+            if ($originalDef && isset($originalDef['locationName'])
+                && $originalDef['locationName'] === $shape['locationName']
+            ) {
+                return $name;
+            }
+        }
+
+        return $shape['locationName'] ?? $name;
+    }
+
+    private function parse_list(ListShape $shape, \SimpleXMLElement  $value)
+    {
+        $target = [];
+        $member = $shape->getMember();
+
+        if (!$shape['flattened']) {
+            $value = $value->{$member['locationName'] ?: 'member'};
+        }
+
+        foreach ($value as $v) {
+            $target[] = $this->dispatch($member, $v);
+        }
+
+        return $target;
+    }
+
+    private function parse_map(MapShape $shape, \SimpleXMLElement $value)
+    {
+        $target = [];
+
+        if (!$shape['flattened']) {
+            $value = $value->entry;
+        }
+
+        $mapKey = $shape->getKey();
+        $mapValue = $shape->getValue();
+        $keyName = $shape->getKey()['locationName'] ?: 'key';
+        $valueName = $shape->getValue()['locationName'] ?: 'value';
+
+        foreach ($value as $node) {
+            $key = $this->dispatch($mapKey, $node->{$keyName});
+            $value = $this->dispatch($mapValue, $node->{$valueName});
+            $target[$key] = $value;
+        }
+
+        return $target;
+    }
+
+    private function parse_blob(Shape $shape, $value)
+    {
+        return base64_decode((string) $value);
+    }
+
+    private function parse_float(Shape $shape, $value)
+    {
+        $value = (string) $value;
+
+        return match ($value) {
+            'NaN', 'Infinity', '-Infinity' => $value,
+            default => (float) $value
+        };
+    }
+
+    private function parse_integer(Shape $shape, $value)
+    {
+        return (int) (string) $value;
+    }
+
+    private function parse_boolean(Shape $shape, $value)
+    {
+        return $value == 'true';
+    }
+
+    private function parse_timestamp(Shape $shape, $value)
+    {
+        if (is_string($value)
+            || is_int($value)
+            || (is_object($value)
+                && method_exists($value, '__toString'))
+        ) {
+            return DateTimeResult::fromTimestamp(
+                (string) $value,
+                !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : null
+            );
+        }
+        throw new ParserException('Invalid timestamp value passed to XmlParser::parse_timestamp');
+    }
+
+    private function parse_xml_attribute(Shape $shape, Shape $memberShape, $value)
+    {
+        $namespace = $shape['xmlNamespace']['uri'] ?? '';
+        $prefix = $shape['xmlNamespace']['prefix'] ?? '';
+        if (!empty($prefix)) {
+            $prefix .= ':';
+        }
+        $key = str_replace($prefix, '', $memberShape['locationName']);
+
+        $attributes = $value->attributes($namespace);
+        return isset($attributes[$key]) ? (string) $attributes[$key] : null;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Serializer/Ec2ParamBuilder.php

@@ -0,0 +1,38 @@
+<?php
+namespace Aws\Api\Serializer;
+
+use Aws\Api\Shape;
+use Aws\Api\ListShape;
+
+/**
+ * @internal
+ */
+class Ec2ParamBuilder extends QueryParamBuilder
+{
+    protected function queryName(Shape $shape, $default = null)
+    {
+        return ($shape['queryName']
+            ?: ucfirst(@$shape['locationName'] ?: ""))
+                ?: $default;
+    }
+
+    protected function isFlat(Shape $shape)
+    {
+        return false;
+    }
+
+    protected function format_list(
+        ListShape $shape,
+        array $value,
+        $prefix,
+        &$query
+    ) {
+        // Handle empty list serialization
+        if (!empty($value)) {
+            $items = $shape->getMember();
+            foreach ($value as $k => $v) {
+                $this->format($items, $v, $prefix . '.' . ($k + 1), $query);
+            }
+        }
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Serializer/JsonBody.php

@@ -0,0 +1,116 @@
+<?php
+namespace Aws\Api\Serializer;
+
+use Aws\Api\Service;
+use Aws\Api\Shape;
+use Aws\Api\TimestampShape;
+use Aws\Exception\InvalidJsonException;
+
+/**
+ * Formats the JSON body of a JSON-REST or JSON-RPC operation.
+ * @internal
+ */
+class JsonBody
+{
+    private $api;
+
+    public function __construct(Service $api)
+    {
+        $this->api = $api;
+    }
+
+    /**
+     * Gets the JSON Content-Type header for a service API
+     *
+     * @param Service $service
+     *
+     * @return string
+     */
+    public static function getContentType(Service $service)
+    {
+        if ($service->getMetadata('protocol') === 'rest-json') {
+            return 'application/json';
+        }
+
+        $jsonVersion = $service->getMetadata('jsonVersion');
+        if (empty($jsonVersion)) {
+            throw new \InvalidArgumentException('invalid json');
+        } else {
+            return 'application/x-amz-json-'
+                . @number_format($service->getMetadata('jsonVersion'), 1);
+        }
+    }
+
+    /**
+     * Builds the JSON body based on an array of arguments.
+     *
+     * @param Shape $shape Operation being constructed
+     * @param array|string $args  Associative array of arguments, or a string.
+     *
+     * @return string
+     */
+    public function build(Shape $shape, array|string $args)
+    {
+        try {
+            $result = json_encode($this->format($shape, $args), JSON_THROW_ON_ERROR);
+        } catch (\JsonException $e) {
+            throw new InvalidJsonException(
+                'Unable to encode JSON document ' . $shape->getName() . ': ' .
+                $e->getMessage() . PHP_EOL
+            );
+        }
+
+        return $result === '[]' ? '{}' : $result;
+    }
+
+    private function format(Shape $shape, $value)
+    {
+        switch ($shape['type']) {
+            case 'structure':
+                $data = [];
+                if ($shape['document'] ?? false) {
+                    return $value;
+                }
+                foreach ($value as $k => $v) {
+                    if ($v !== null && $shape->hasMember($k)) {
+                        $valueShape = $shape->getMember($k);
+                        $data[$valueShape['locationName'] ?: $k]
+                            = $this->format($valueShape, $v);
+                    }
+                }
+                if (empty($data)) {
+                    return new \stdClass;
+                }
+                return $data;
+
+            case 'list':
+                $items = $shape->getMember();
+                foreach ($value as $k => $v) {
+                    $value[$k] = $this->format($items, $v);
+                }
+                return $value;
+
+            case 'map':
+                if (empty($value)) {
+                    return new \stdClass;
+                }
+                $values = $shape->getValue();
+                foreach ($value as $k => $v) {
+                    $value[$k] = $this->format($values, $v);
+                }
+                return $value;
+
+            case 'blob':
+                return base64_encode($value);
+
+            case 'timestamp':
+                $timestampFormat = !empty($shape['timestampFormat'])
+                    ? $shape['timestampFormat']
+                    : 'unixTimestamp';
+                return TimestampShape::format($value, $timestampFormat);
+
+            default:
+                return $value;
+        }
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Serializer/JsonRpcSerializer.php

@@ -0,0 +1,87 @@
+<?php
+namespace Aws\Api\Serializer;
+
+use Aws\Api\Service;
+use Aws\CommandInterface;
+use Aws\EndpointV2\EndpointV2SerializerTrait;
+use Aws\EndpointV2\Ruleset\RulesetEndpoint;
+use GuzzleHttp\Psr7\Request;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Prepares a JSON-RPC request for transfer.
+ * @internal
+ */
+class JsonRpcSerializer
+{
+    use EndpointV2SerializerTrait;
+
+    /** @var JsonBody */
+    private $jsonFormatter;
+
+    /** @var string */
+    private $endpoint;
+
+    /** @var Service */
+    private $api;
+
+    /** @var string */
+    private $contentType;
+
+    /**
+     * @param Service  $api           Service description
+     * @param string   $endpoint      Endpoint to connect to
+     * @param JsonBody $jsonFormatter Optional JSON formatter to use
+     */
+    public function __construct(
+        Service $api,
+        $endpoint,
+        ?JsonBody $jsonFormatter = null
+    ) {
+        $this->endpoint = $endpoint;
+        $this->api = $api;
+        $this->jsonFormatter = $jsonFormatter ?: new JsonBody($this->api);
+        $this->contentType = JsonBody::getContentType($api);
+    }
+
+    /**
+     * When invoked with an AWS command, returns a serialization array
+     * containing "method", "uri", "headers", and "body" key value pairs.
+     *
+     * @param CommandInterface $command Command to serialize into a request.
+     * @param $endpointProvider Provider used for dynamic endpoint resolution.
+     * @param $clientArgs Client arguments used for dynamic endpoint resolution.
+     *
+     * @return RequestInterface
+     */
+    public function __invoke(
+        CommandInterface $command,
+        $endpoint = null
+    )
+    {
+        $operationName = $command->getName();
+        $operation = $this->api->getOperation($operationName);
+        $commandArgs = $command->toArray();
+        $body = $this->jsonFormatter->build($operation->getInput(), $commandArgs);
+        $headers = [
+                'X-Amz-Target' => $this->api->getMetadata('targetPrefix') . '.' . $operationName,
+                'Content-Type' => $this->contentType,
+                'Content-Length' => strlen($body)
+        ];
+
+        if ($endpoint instanceof RulesetEndpoint) {
+            $this->setEndpointV2RequestOptions($endpoint, $headers);
+        }
+
+        $requestUri = $operation['http']['requestUri'] ?? null;
+        $absoluteUri = str_ends_with($this->endpoint, '/')
+            ? $this->endpoint : $this->endpoint . $requestUri;
+
+        return new Request(
+            $operation['http']['method'],
+            $absoluteUri,
+            $headers,
+            $body
+        );
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Serializer/QueryParamBuilder.php

@@ -0,0 +1,158 @@
+<?php
+namespace Aws\Api\Serializer;
+
+use Aws\Api\StructureShape;
+use Aws\Api\ListShape;
+use Aws\Api\MapShape;
+use Aws\Api\Shape;
+use Aws\Api\TimestampShape;
+
+/**
+ * @internal
+ */
+class QueryParamBuilder
+{
+    private $methods;
+
+    protected function queryName(Shape $shape, $default = null)
+    {
+        if (null !== $shape['queryName']) {
+            return $shape['queryName'];
+        }
+
+        if (null !== $shape['locationName']) {
+            return $shape['locationName'];
+        }
+
+        if ($this->isFlat($shape) && !empty($shape['member']['locationName'])) {
+            return $shape['member']['locationName'];
+        }
+
+        return $default;
+    }
+
+    protected function isFlat(Shape $shape)
+    {
+        return $shape['flattened'] === true;
+    }
+
+    public function __invoke(StructureShape $shape, array $params)
+    {
+        if (!$this->methods) {
+            $this->methods = array_fill_keys(get_class_methods($this), true);
+        }
+
+        $query = [];
+        $this->format_structure($shape, $params, '', $query);
+
+        return $query;
+    }
+
+    protected function format(Shape $shape, $value, $prefix, array &$query)
+    {
+        $type = 'format_' . $shape['type'];
+        if (isset($this->methods[$type])) {
+            $this->{$type}($shape, $value, $prefix, $query);
+        } else {
+            $query[$prefix] = (string) $value;
+        }
+    }
+
+    protected function format_structure(
+        StructureShape $shape,
+        array $value,
+        $prefix,
+        &$query
+    ) {
+        if ($prefix) {
+            $prefix .= '.';
+        }
+
+        foreach ($value as $k => $v) {
+            if ($shape->hasMember($k)) {
+                $member = $shape->getMember($k);
+                $this->format(
+                    $member,
+                    $v,
+                    $prefix . $this->queryName($member, $k),
+                    $query
+                );
+            }
+        }
+    }
+
+    protected function format_list(
+        ListShape $shape,
+        array $value,
+        $prefix,
+        &$query
+    ) {
+        // Handle empty list serialization
+        if (!$value) {
+            $query[$prefix] = '';
+            return;
+        }
+
+        $items = $shape->getMember();
+
+        if (!$this->isFlat($shape)) {
+            $locationName = $shape->getMember()['locationName'] ?: 'member';
+            $prefix .= ".$locationName";
+            // flattened lists can also model a `locationName`
+        } elseif ($name = $shape['locationName'] ?? $this->queryName($items)) {
+            $parts = explode('.', $prefix);
+            $parts[count($parts) - 1] = $name;
+            $prefix = implode('.', $parts);
+        }
+
+        foreach ($value as $k => $v) {
+            $this->format($items, $v, $prefix . '.' . ($k + 1), $query);
+        }
+    }
+
+    protected function format_map(
+        MapShape $shape,
+        array $value,
+        $prefix,
+        array &$query
+    ) {
+        $vals = $shape->getValue();
+        $keys = $shape->getKey();
+
+        if (!$this->isFlat($shape)) {
+            $prefix .= '.entry';
+        }
+
+        $i = 0;
+        $keyName = '%s.%d.' . $this->queryName($keys, 'key');
+        $valueName = '%s.%s.' . $this->queryName($vals, 'value');
+
+        foreach ($value as $k => $v) {
+            $i++;
+            $this->format($keys, $k, sprintf($keyName, $prefix, $i), $query);
+            $this->format($vals, $v, sprintf($valueName, $prefix, $i), $query);
+        }
+    }
+
+    protected function format_blob(Shape $shape, $value, $prefix, array &$query)
+    {
+        $query[$prefix] = base64_encode($value);
+    }
+
+    protected function format_timestamp(
+        TimestampShape $shape,
+        $value,
+        $prefix,
+        array &$query
+    ) {
+        $timestampFormat = !empty($shape['timestampFormat'])
+            ? $shape['timestampFormat']
+            : 'iso8601';
+        $query[$prefix] = TimestampShape::format($value, $timestampFormat);
+    }
+
+    protected function format_boolean(Shape $shape, $value, $prefix, array &$query)
+    {
+        $query[$prefix] = ($value) ? 'true' : 'false';
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Serializer/QuerySerializer.php

@@ -0,0 +1,82 @@
+<?php
+namespace Aws\Api\Serializer;
+
+use Aws\Api\Service;
+use Aws\CommandInterface;
+use Aws\EndpointV2\EndpointProviderV2;
+use Aws\EndpointV2\EndpointV2SerializerTrait;
+use Aws\EndpointV2\Ruleset\RulesetEndpoint;
+use GuzzleHttp\Psr7\Request;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Serializes a query protocol request.
+ * @internal
+ */
+class QuerySerializer
+{
+    use EndpointV2SerializerTrait;
+
+    private $endpoint;
+    private $api;
+    private $paramBuilder;
+
+    public function __construct(
+        Service $api,
+        $endpoint,
+        ?callable $paramBuilder = null
+    ) {
+        $this->api = $api;
+        $this->endpoint = $endpoint;
+        $this->paramBuilder = $paramBuilder ?: new QueryParamBuilder();
+    }
+
+    /**
+     * When invoked with an AWS command, returns a serialization array
+     * containing "method", "uri", "headers", and "body" key value pairs.
+     *
+     * @param CommandInterface $command Command to serialize into a request.
+     * @param null $endpoint Endpoint resolved using EndpointProviderV2
+     * @return RequestInterface
+     */
+    public function __invoke(
+        CommandInterface $command,
+        $endpoint = null
+    )
+    {
+        $operation = $this->api->getOperation($command->getName());
+        $body = [
+            'Action'  => $command->getName(),
+            'Version' => $this->api->getMetadata('apiVersion')
+        ];
+        $commandArgs = $command->toArray();
+
+        // Only build up the parameters when there are parameters to build
+        if ($commandArgs) {
+            $body += call_user_func(
+                $this->paramBuilder,
+                $operation->getInput(),
+                $commandArgs
+            );
+        }
+        $body = http_build_query($body, '', '&', PHP_QUERY_RFC3986);
+        $headers = [
+            'Content-Length' => strlen($body),
+            'Content-Type'   => 'application/x-www-form-urlencoded'
+        ];
+        $requestUri = $operation['http']['requestUri'] ?? null;
+
+        if ($endpoint instanceof RulesetEndpoint) {
+            $this->setEndpointV2RequestOptions($endpoint, $headers);
+        }
+        $absoluteUri = str_ends_with($this->endpoint, '/')
+            ? $this->endpoint : $this->endpoint . $requestUri;
+
+        return new Request(
+            'POST',
+            $absoluteUri,
+            $headers,
+            $body
+        );
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Serializer/RestJsonSerializer.php

@@ -0,0 +1,41 @@
+<?php
+namespace Aws\Api\Serializer;
+
+use Aws\Api\Service;
+use Aws\Api\StructureShape;
+
+/**
+ * Serializes requests for the REST-JSON protocol.
+ * @internal
+ */
+class RestJsonSerializer extends RestSerializer
+{
+    /** @var JsonBody */
+    private $jsonFormatter;
+
+    /** @var string */
+    private $contentType;
+
+    /**
+     * @param Service  $api           Service API description
+     * @param string   $endpoint      Endpoint to connect to
+     * @param JsonBody $jsonFormatter Optional JSON formatter to use
+     */
+    public function __construct(
+        Service $api,
+        $endpoint,
+        ?JsonBody $jsonFormatter = null
+    ) {
+        parent::__construct($api, $endpoint);
+        $this->contentType = JsonBody::getContentType($api);
+        $this->jsonFormatter = $jsonFormatter ?: new JsonBody($api);
+    }
+
+    protected function payload(StructureShape $member, array|string $value, array &$opts)
+    {
+        $opts['headers']['Content-Type'] = $this->contentType;
+        $body = $this->jsonFormatter->build($member, $value);
+        $opts['headers']['Content-Length'] = strlen($body);
+        $opts['body'] = $body;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Serializer/RestSerializer.php

@@ -0,0 +1,486 @@
+<?php
+namespace Aws\Api\Serializer;
+
+use Aws\Api\ListShape;
+use Aws\Api\MapShape;
+use Aws\Api\Service;
+use Aws\Api\Operation;
+use Aws\Api\Shape;
+use Aws\Api\StructureShape;
+use Aws\Api\TimestampShape;
+use Aws\CommandInterface;
+use Aws\EndpointV2\EndpointV2SerializerTrait;
+use Aws\EndpointV2\Ruleset\RulesetEndpoint;
+use DateTimeInterface;
+use GuzzleHttp\Psr7;
+use GuzzleHttp\Psr7\Request;
+use GuzzleHttp\Psr7\Uri;
+use GuzzleHttp\Psr7\UriResolver;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\UriInterface;
+
+/**
+ * Serializes HTTP locations like header, uri, payload, etc...
+ * @internal
+ */
+abstract class RestSerializer
+{
+    private const TEMPLATE_STRING_REGEX = '/\{([^\}]+)\}/';
+
+    private static array $excludeContentType = [
+        's3' => true,
+        'glacier' => true
+    ];
+
+    /** @var Service */
+    private Service $api;
+
+    /** @var Uri */
+    private $endpoint;
+
+    /** @var bool */
+    private $isUseEndpointV2;
+
+    use EndpointV2SerializerTrait;
+
+    /**
+     * @param Service $api Service API description
+     * @param string $endpoint Endpoint to connect to
+     */
+    public function __construct(Service $api, $endpoint)
+    {
+        $this->api = $api;
+        $this->endpoint = Psr7\Utils::uriFor($endpoint);
+    }
+
+    /**
+     * @param CommandInterface $command Command to serialize into a request.
+     * @param mixed|null $endpoint
+     * @return RequestInterface
+     */
+    public function __invoke(
+        CommandInterface $command,
+        mixed $endpoint = null
+    )
+    {
+        $operation = $this->api->getOperation($command->getName());
+        $commandArgs = $command->toArray();
+        $opts = $this->serialize($operation, $commandArgs);
+        $headers = $opts['headers'] ?? [];
+
+        if ($endpoint instanceof RulesetEndpoint) {
+            $this->isUseEndpointV2 = true;
+            $this->setEndpointV2RequestOptions($endpoint, $headers);
+        }
+
+        $uri = $this->buildEndpoint($operation, $commandArgs, $opts);
+
+        return new Request(
+            $operation['http']['method'],
+            $uri,
+            $headers,
+            $opts['body'] ?? null
+        );
+    }
+
+    /**
+     * Modifies a hash of request options for a payload body.
+     *
+     * @param StructureShape $member Member to serialize
+     * @param array $value Value to serialize
+     * @param array $opts Request options to modify.
+     */
+    abstract protected function payload(
+        StructureShape $member,
+        array $value,
+        array &$opts
+    );
+
+    private function serialize(Operation $operation, array $args)
+    {
+        $opts = [];
+        $input = $operation->getInput();
+
+        // Apply the payload trait if present
+        if ($payload = $input['payload']) {
+            $this->applyPayload($input, $payload, $args, $opts);
+        }
+
+        foreach ($args as $name => $value) {
+            if ($input->hasMember($name)) {
+                $member = $input->getMember($name);
+                $location = $member['location'];
+                if (!$payload && !$location) {
+                    $bodyMembers[$name] = $value;
+                } elseif ($location === 'header') {
+                    $this->applyHeader($name, $member, $value, $opts);
+                } elseif ($location === 'querystring') {
+                    $this->applyQuery($name, $member, $value, $opts);
+                } elseif ($location === 'headers') {
+                    $this->applyHeaderMap($name, $member, $value, $opts);
+                }
+            }
+        }
+
+        if (isset($bodyMembers)) {
+            $this->payload($input, $bodyMembers, $opts);
+        } else if (!isset($opts['body']) && $this->hasPayloadParam($input, $payload)) {
+            $this->payload($input, [], $opts);
+        }
+
+        return $opts;
+    }
+
+    private function applyPayload(StructureShape $input, $name, array $args, array &$opts)
+    {
+        if (!isset($args[$name])) {
+            return;
+        }
+
+        $m = $input->getMember($name);
+
+        $type = $m->getType();
+        if ($m['streaming'] ||
+           ($type === 'string' || $type === 'blob')
+        ) {
+            // This path skips setting the content-type header usually done in
+            // RestJsonSerializer and RestXmlSerializer.certain S3 and glacier
+            // operations determine content type in Middleware::ContentType()
+            if (!isset(self::$excludeContentType[$this->api->getServiceName()])) {
+                switch ($type) {
+                    case 'string':
+                        $opts['headers']['Content-Type'] = 'text/plain';
+                        break;
+                    case 'blob':
+                        $opts['headers']['Content-Type'] = 'application/octet-stream';
+                        break;
+                }
+            }
+
+            $body = $args[$name];
+            if (!$m['streaming'] && is_string($body)) {
+                $opts['headers']['Content-Length'] = strlen($body);
+            }
+
+            // Streaming bodies or payloads that are strings are
+            // always just a stream of data.
+            $opts['body'] = Psr7\Utils::streamFor($body);
+            return;
+        }
+
+        $this->payload($m, $args[$name], $opts);
+    }
+
+    private function applyHeader($name, Shape $member, $value, array &$opts)
+    {
+        // Handle lists by recursively applying header logic to each element
+        if ($member instanceof ListShape) {
+            $listMember = $member->getMember();
+            $headerValues = [];
+
+            foreach ($value as $listValue) {
+                $tempOpts = ['headers' => []];
+                $this->applyHeader('temp', $listMember, $listValue, $tempOpts);
+                $convertedValue = $tempOpts['headers']['temp'];
+                $headerValues[] = $convertedValue;
+            }
+
+            $value = $headerValues;
+        } elseif (!is_null($value)) {
+            switch ($member->getType()) {
+                case 'timestamp':
+                    $timestampFormat = $member['timestampFormat'] ?? 'rfc822';
+                    $value = $this->formatTimestamp($value, $timestampFormat);
+                    break;
+                case 'boolean':
+                    $value = $this->formatBoolean($value);
+                    break;
+            }
+        }
+
+        if ($member['jsonvalue']) {
+            $value = json_encode($value);
+            if (empty($value) && JSON_ERROR_NONE !== json_last_error()) {
+                throw new \InvalidArgumentException('Unable to encode the provided value'
+                    . ' with \'json_encode\'. ' . json_last_error_msg());
+            }
+
+            $value = base64_encode($value);
+        }
+
+        $opts['headers'][$member['locationName'] ?: $name] = $value;
+    }
+
+    /**
+     * Note: This is currently only present in the Amazon S3 model.
+     */
+    private function applyHeaderMap($name, Shape $member, array $value, array &$opts)
+    {
+        $prefix = $member['locationName'];
+        foreach ($value as $k => $v) {
+            $opts['headers'][$prefix . $k] = $v;
+        }
+    }
+
+    private function applyQuery($name, Shape $member, $value, array &$opts)
+    {
+        if ($member instanceof MapShape) {
+            $opts['query'] = isset($opts['query']) && is_array($opts['query'])
+                ? $opts['query'] + $value
+                : $value;
+        } elseif ($member instanceof ListShape) {
+            $listMember = $member->getMember();
+            $paramName = $member['locationName'] ?: $name;
+
+            foreach ($value as $listValue) {
+                // Recursively call applyQuery for each list element
+                $tempOpts = ['query' => []];
+                $this->applyQuery('temp', $listMember, $listValue, $tempOpts);
+                $opts['query'][$paramName][] = $tempOpts['query']['temp'];
+            }
+        } elseif (!is_null($value)) {
+            switch ($member->getType()) {
+                case 'timestamp':
+                    $timestampFormat = $member['timestampFormat'] ?? 'iso8601';
+                    $value = $this->formatTimestamp($value, $timestampFormat);
+                    break;
+                case 'boolean':
+                    $value = $this->formatBoolean($value);
+                    break;
+            }
+
+            $opts['query'][$member['locationName'] ?: $name] = $value;
+        }
+    }
+
+    private function buildEndpoint(
+        Operation $operation,
+        array $args,
+        array $opts
+    ): UriInterface
+    {
+        // Expand `requestUri` field members
+        $relativeUri = $this->expandUriTemplate($operation, $args);
+
+        // Add query members to relativeUri
+        if (!empty($opts['query'])) {
+            $relativeUri = $this->appendQuery($opts['query'], $relativeUri);
+        }
+
+        // Special case - S3 keys that need path preservation
+        if ($this->api->getServiceName() === 's3'
+            && isset($args['Key'])
+            && $this->shouldPreservePath($args['Key'])
+        ) {
+            return new Uri($this->endpoint . $relativeUri);
+        }
+
+        return $this->resolveUri($relativeUri, $opts);
+    }
+
+    /**
+     * Expands `requestUri` members
+     *
+     * @param Operation $operation
+     * @param array $args
+     *
+     * @return string
+     */
+    private function expandUriTemplate(Operation $operation, array $args): string
+    {
+        $varDefinitions = $this->getVarDefinitions($operation, $args);
+
+        return preg_replace_callback(
+            self::TEMPLATE_STRING_REGEX,
+            static function (array $matches) use ($varDefinitions) {
+                $isGreedy = str_ends_with($matches[1], '+');
+                $varName = $isGreedy ? substr($matches[1], 0, -1) : $matches[1];
+
+                if (!isset($varDefinitions[$varName])) {
+                    return '';
+                }
+
+                $value = $varDefinitions[$varName];
+
+                if ($isGreedy) {
+                    return str_replace('%2F', '/', rawurlencode($value));
+                }
+
+                return rawurlencode($value);
+            },
+            $operation['http']['requestUri']
+        );
+    }
+
+    /**
+     * Checks for path-like key names. If detected, traditional
+     * URI resolution is bypassed.
+     *
+     * @param string $key
+     * @return bool
+     */
+    private function shouldPreservePath(string $key): bool
+    {
+        // Keys with dot segments
+        if (str_contains($key, '.')) {
+            $segments = explode('/', $key);
+            foreach ($segments as $segment) {
+                if ($segment === '.' || $segment === '..') {
+                    return true;
+                }
+            }
+        }
+
+        // Keys starting with slash
+        if (str_starts_with($key, '/')) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * @param string $relativeUri
+     * @param array $opts
+     *
+     * @return UriInterface
+     */
+    private function resolveUri(string $relativeUri, array $opts): UriInterface
+    {
+        $basePath = $this->endpoint->getPath();
+
+        // Only process if we have a non-empty base path
+        if (!empty($basePath) && $basePath !== '/') {
+            // if relative is just '/', we want just the base path without trailing slash
+            if ($relativeUri === '/' || empty($relativeUri)) {
+                // Remove trailing slash if present
+                return $this->endpoint->withPath(rtrim($basePath, '/'));
+            }
+
+            // if relative is '/?query', we want base path without trailing slash + query
+            // for now, this is only seen with S3 GetBucketLocation after processing the model
+            if (empty($opts['query'])
+                && str_starts_with($relativeUri, '/?')
+            ) {
+                $query = substr($relativeUri, 2); // Remove '/?'
+                return $this->endpoint->withQuery($query);
+            }
+
+            // Ensure base path has trailing slash
+            if (!str_ends_with($basePath, '/')) {
+                $this->endpoint = $this->endpoint->withPath($basePath . '/');
+            }
+
+            // Remove leading slash from relative path to make it relative
+            if (str_starts_with($relativeUri, '/')) {
+                $relativeUri = substr($relativeUri, 1);
+            }
+        }
+
+        return UriResolver::resolve($this->endpoint, new Uri($relativeUri));
+    }
+
+    /**
+     * @param StructureShape $input
+     * @param $payload
+     *
+     * @return bool
+     */
+    private function hasPayloadParam(StructureShape $input, $payload)
+    {
+        if ($payload) {
+            $potentiallyEmptyTypes = ['blob','string'];
+            if ($this->api->getProtocol() === 'rest-xml') {
+                $potentiallyEmptyTypes[] = 'structure';
+            }
+
+            $payloadMember = $input->getMember($payload);
+            //unions may also be empty/unset
+            if (!empty($payloadMember['union'])
+                || in_array($payloadMember['type'], $potentiallyEmptyTypes)
+            ) {
+                return false;
+            }
+        }
+
+        foreach ($input->getMembers() as $member) {
+            if (!isset($member['location'])) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @param $query
+     * @param $relativeUri
+     *
+     * @return string
+     */
+    private function appendQuery($query, $relativeUri): string
+    {
+        $append = Psr7\Query::build($query);
+        return $relativeUri
+            . (str_contains($relativeUri, '?') ? "&{$append}" : "?{$append}");
+    }
+
+    /**
+     * @param CommandInterface $command
+     * @param array $args
+     *
+     * @return array
+     */
+    private function getVarDefinitions(
+        Operation $operation,
+        array $args
+    ): array
+    {
+        $varDefinitions = [];
+
+        foreach ($operation->getInput()->getMembers() as $name => $member) {
+            if ($member['location'] === 'uri') {
+                $value = $args[$name] ?? null;
+                if (!is_null($value)) {
+                    switch ($member->getType()) {
+                        case 'timestamp':
+                            $timestampFormat = $member['timestampFormat'] ?? 'iso8601';
+                            $value = $this->formatTimestamp($value, $timestampFormat);
+                            break;
+                        case 'boolean':
+                            $value = $this->formatBoolean($value);
+                            break;
+                    }
+                }
+
+                $varDefinitions[$member['locationName'] ?: $name] = $value;
+            }
+        }
+
+        return $varDefinitions;
+    }
+
+    /**
+     * @param DateTimeInterface|string|int $value
+     * @param string $timestampFormat
+     *
+     * @return string
+     */
+    private function formatTimestamp(
+        DateTimeInterface|string|int $value,
+        string $timestampFormat
+    ): string
+    {
+        return TimestampShape::format($value, $timestampFormat);
+    }
+
+    /**
+     * @param $value
+     *
+     * @return string
+     */
+    private function formatBoolean($value): string
+    {
+        return $value ? 'true' : 'false';
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Serializer/RestXmlSerializer.php

@@ -0,0 +1,50 @@
+<?php
+namespace Aws\Api\Serializer;
+
+use Aws\Api\StructureShape;
+use Aws\Api\Service;
+
+/**
+ * @internal
+ */
+class RestXmlSerializer extends RestSerializer
+{
+    /** @var XmlBody */
+    private $xmlBody;
+
+    /**
+     * @param Service $api      Service API description
+     * @param string  $endpoint Endpoint to connect to
+     * @param XmlBody $xmlBody  Optional XML formatter to use
+     */
+    public function __construct(
+        Service $api,
+        $endpoint,
+        ?XmlBody $xmlBody = null
+    ) {
+        parent::__construct($api, $endpoint);
+        $this->xmlBody = $xmlBody ?: new XmlBody($api);
+    }
+
+    protected function payload(StructureShape $member, array $value, array &$opts)
+    {
+        $opts['headers']['Content-Type'] = 'application/xml';
+        $body = $this->getXmlBody($member, $value);
+        $opts['headers']['Content-Length'] = strlen($body);
+        $opts['body'] = $body;
+    }
+
+    /**
+     * @param StructureShape $member
+     * @param array $value
+     * @return string
+     */
+    private function getXmlBody(StructureShape $member, array $value)
+    {
+        $xmlBody = (string)$this->xmlBody->build($member, $value);
+        $xmlBody = str_replace("'", "&apos;", $xmlBody);
+        $xmlBody = str_replace('\r', "&#13;", $xmlBody);
+        $xmlBody = str_replace('\n', "&#10;", $xmlBody);
+        return $xmlBody;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Serializer/XmlBody.php

@@ -0,0 +1,256 @@
+<?php
+namespace Aws\Api\Serializer;
+
+use Aws\Api\MapShape;
+use Aws\Api\Service;
+use Aws\Api\Shape;
+use Aws\Api\StructureShape;
+use Aws\Api\ListShape;
+use Aws\Api\TimestampShape;
+use XMLWriter;
+
+/**
+ * @internal Formats the XML body of a REST-XML services.
+ */
+class XmlBody
+{
+    /** @var Service */
+    private Service $api;
+
+    /**
+     * @param Service $api API being used to create the XML body.
+     */
+    public function __construct(Service $api)
+    {
+        $this->api = $api;
+    }
+
+    /**
+     * Builds the XML body based on an array of arguments.
+     *
+     * @param Shape $shape Operation being constructed
+     * @param array $args  Associative array of arguments
+     *
+     * @return string
+     */
+    public function build(Shape $shape, array $args)
+    {
+        $xml = new XMLWriter();
+        $xml->openMemory();
+        $xml->startDocument('1.0', 'UTF-8');
+
+        $rootElementName = $this->determineRootElementName($shape);
+
+        $this->format($shape, $rootElementName, $args, $xml);
+        $xml->endDocument();
+
+        return $xml->outputMemory();
+    }
+
+    private function startElement(Shape $shape, $name, XMLWriter $xml)
+    {
+        $xml->startElement($name);
+
+        if ($ns = $shape['xmlNamespace']) {
+            $xml->writeAttribute(
+                isset($ns['prefix']) ? "xmlns:{$ns['prefix']}" : 'xmlns',
+                $ns['uri']
+            );
+        }
+    }
+
+    private function format(Shape $shape, $name, $value, XMLWriter $xml)
+    {
+        // Any method mentioned here has a custom serialization handler.
+        static $methods = [
+            'add_structure' => true,
+            'add_list'      => true,
+            'add_blob'      => true,
+            'add_timestamp' => true,
+            'add_boolean'   => true,
+            'add_map'       => true,
+            'add_string'    => true
+        ];
+
+        $type = 'add_' . $shape['type'];
+        if (isset($methods[$type])) {
+            $this->{$type}($shape, $name, $value, $xml);
+        } else {
+            $this->defaultShape($shape, $name, $value, $xml);
+        }
+    }
+
+    private function defaultShape(Shape $shape, $name, $value, XMLWriter $xml)
+    {
+        $this->startElement($shape, $name, $xml);
+        $xml->text($value);
+        $xml->endElement();
+    }
+
+    private function add_structure(
+        StructureShape $shape,
+        $name,
+        array $value,
+        \XMLWriter $xml
+    ) {
+        $this->startElement($shape, $name, $xml);
+
+        foreach ($this->getStructureMembers($shape, $value) as $k => $definition) {
+            // Default to member name
+            $elementName = $k;
+
+            // Only use locationName for non-structure members
+            if (!($definition['member'] instanceof StructureShape)
+                && $definition['member']['locationName']
+            ) {
+                $elementName = $definition['member']['locationName'];
+            }
+
+            $this->format(
+                $definition['member'],
+                $elementName,
+                $definition['value'],
+                $xml
+            );
+        }
+
+        $xml->endElement();
+    }
+
+    private function getStructureMembers(StructureShape $shape, array $value)
+    {
+        $members = [];
+
+        foreach ($value as $k => $v) {
+            if ($v !== null && $shape->hasMember($k)) {
+                $definition = [
+                    'member' => $shape->getMember($k),
+                    'value'  => $v,
+                ];
+
+                if ($definition['member']['xmlAttribute']) {
+                    // array_unshift_associative
+                    $members = [$k => $definition] + $members;
+                } else {
+                    $members[$k] = $definition;
+                }
+            }
+        }
+
+        return $members;
+    }
+
+    private function add_list(
+        ListShape $shape,
+        $name,
+        array $value,
+        XMLWriter $xml
+    ) {
+        $items = $shape->getMember();
+
+        if ($shape['flattened']) {
+            $elementName = $name;
+        } else {
+            $this->startElement($shape, $name, $xml);
+            $elementName = $items['locationName'] ?: 'member';
+        }
+
+        foreach ($value as $v) {
+            $this->format($items, $elementName, $v, $xml);
+        }
+
+        if (!$shape['flattened']) {
+            $xml->endElement();
+        }
+    }
+
+    private function add_map(
+        MapShape $shape,
+        $name,
+        array $value,
+        XMLWriter $xml
+    ) {
+        $xmlEntry = $shape['flattened'] ? $name : 'entry';
+        $xmlKey = $shape->getKey()['locationName'] ?: 'key';
+        $xmlValue = $shape->getValue()['locationName'] ?: 'value';
+
+        if (!$shape['flattened']) {
+            $this->startElement($shape, $name, $xml);
+        }
+
+        foreach ($value as $key => $v) {
+            $this->startElement($shape, $xmlEntry, $xml);
+            $this->format($shape->getKey(), $xmlKey, $key, $xml);
+            $this->format($shape->getValue(), $xmlValue, $v, $xml);
+            $xml->endElement();
+        }
+
+        if (!$shape['flattened']) {
+            $xml->endElement();
+        }
+    }
+
+    private function add_blob(Shape $shape, $name, $value, XMLWriter $xml)
+    {
+        $this->startElement($shape, $name, $xml);
+        $xml->writeRaw(base64_encode($value));
+        $xml->endElement();
+    }
+
+    private function add_timestamp(
+        TimestampShape $shape,
+        $name,
+        $value,
+        XMLWriter $xml
+    ) {
+        $this->startElement($shape, $name, $xml);
+        $timestampFormat = !empty($shape['timestampFormat'])
+            ? $shape['timestampFormat']
+            : 'iso8601';
+        $xml->writeRaw(TimestampShape::format($value, $timestampFormat));
+        $xml->endElement();
+    }
+
+    private function add_boolean(
+        Shape $shape,
+        $name,
+        $value,
+        XMLWriter $xml
+    ) {
+        $this->startElement($shape, $name, $xml);
+        $xml->writeRaw($value ? 'true' : 'false');
+        $xml->endElement();
+    }
+
+    private function add_string(
+        Shape $shape,
+        $name,
+        $value,
+        XMLWriter $xml
+    ) {
+        if ($shape['xmlAttribute']) {
+            $xml->writeAttribute($shape['locationName'] ?: $name, $value);
+        } else {
+            $this->defaultShape($shape, $name, $value, $xml);
+        }
+    }
+
+    private function determineRootElementName(Shape $shape): string
+    {
+        $shapeName = $shape->getName();
+
+        // Look up the shape definition first
+        if ($shapeName && $shapeMap = $shape->getShapeMap()) {
+            if (isset($shapeMap[$shapeName]['locationName'])) {
+                return $shapeMap[$shapeName]['locationName'];
+            }
+        }
+
+        // Fall back to shape's current locationName
+        if ($shape['locationName']) {
+            return $shape['locationName'];
+        }
+
+        return $shapeName;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Service.php

@@ -0,0 +1,564 @@
+<?php
+namespace Aws\Api;
+
+/**
+ * Represents a web service API model.
+ */
+class Service extends AbstractModel
+{
+    /** @var callable */
+    private $apiProvider;
+
+    /** @var string */
+    private $serviceName;
+
+    /** @var string */
+    private $apiVersion;
+
+    /** @var array */
+    private $clientContextParams = [];
+
+    /** @var Operation[] */
+    private $operations = [];
+
+    /** @var array */
+    private $paginators = null;
+
+    /** @var array */
+    private $waiters = null;
+
+    /** @var boolean */
+    private $modifiedModel = false;
+
+    /** @var string */
+    private $protocol;
+
+    /**
+     * @param array    $definition
+     * @param callable $provider
+     *
+     * @internal param array $definition Service description
+     */
+    public function __construct(array $definition, callable $provider)
+    {
+        static $defaults = [
+            'operations' => [],
+            'shapes'     => [],
+            'metadata'   => [],
+            'clientContextParams' => []
+        ], $defaultMeta = [
+            'apiVersion'       => null,
+            'serviceFullName'  => null,
+            'serviceId'        => null,
+            'endpointPrefix'   => null,
+            'signingName'      => null,
+            'signatureVersion' => null,
+            'protocol'         => null,
+            'uid'              => null
+        ];
+
+        $definition += $defaults;
+        $definition['metadata'] += $defaultMeta;
+        $this->definition = $definition;
+        $this->apiProvider = $provider;
+        parent::__construct($definition, new ShapeMap($definition['shapes']));
+
+        if (isset($definition['metadata']['serviceIdentifier'])) {
+            $this->serviceName = $this->getServiceName();
+        } else {
+            $this->serviceName = $this->getEndpointPrefix();
+        }
+        $this->apiVersion = $this->getApiVersion();
+        if (isset($definition['clientContextParams'])) {
+           $this->clientContextParams = $definition['clientContextParams'];
+        }
+
+        $this->protocol = $this->selectProtocol($definition);
+    }
+
+    /**
+     * Creates a request serializer for the provided API object.
+     *
+     * @param Service $api      API that contains a protocol.
+     * @param string  $endpoint Endpoint to send requests to.
+     *
+     * @return callable
+     * @throws \UnexpectedValueException
+     */
+    public static function createSerializer(Service $api, $endpoint)
+    {
+        static $mapping = [
+            'json'      => Serializer\JsonRpcSerializer::class,
+            'query'     => Serializer\QuerySerializer::class,
+            'rest-json' => Serializer\RestJsonSerializer::class,
+            'rest-xml'  => Serializer\RestXmlSerializer::class
+        ];
+
+        $proto = $api->getProtocol();
+
+        if (isset($mapping[$proto])) {
+            return new $mapping[$proto]($api, $endpoint);
+        }
+
+        if ($proto == 'ec2') {
+            return new Serializer\QuerySerializer($api, $endpoint, new Serializer\Ec2ParamBuilder());
+        }
+
+        throw new \UnexpectedValueException(
+            'Unknown protocol: ' . $api->getProtocol()
+        );
+    }
+
+    /**
+     * Creates an error parser for the given protocol.
+     *
+     * Redundant method signature to preserve backwards compatibility.
+     *
+     * @param string $protocol Protocol to parse (e.g., query, json, etc.)
+     *
+     * @return callable
+     * @throws \UnexpectedValueException
+     */
+    public static function createErrorParser($protocol, ?Service $api = null)
+    {
+        static $mapping = [
+            'json'      => ErrorParser\JsonRpcErrorParser::class,
+            'query'     => ErrorParser\XmlErrorParser::class,
+            'rest-json' => ErrorParser\RestJsonErrorParser::class,
+            'rest-xml'  => ErrorParser\XmlErrorParser::class,
+            'ec2'       => ErrorParser\XmlErrorParser::class
+        ];
+
+        if (isset($mapping[$protocol])) {
+            return new $mapping[$protocol]($api);
+        }
+
+        throw new \UnexpectedValueException("Unknown protocol: $protocol");
+    }
+
+    /**
+     * Applies the listeners needed to parse client models.
+     *
+     * @param Service $api API to create a parser for
+     * @return callable
+     * @throws \UnexpectedValueException
+     */
+    public static function createParser(Service $api)
+    {
+        static $mapping = [
+            'json'      => Parser\JsonRpcParser::class,
+            'query'     => Parser\QueryParser::class,
+            'rest-json' => Parser\RestJsonParser::class,
+            'rest-xml'  => Parser\RestXmlParser::class
+        ];
+
+        $proto = $api->getProtocol();
+        if (isset($mapping[$proto])) {
+            return new $mapping[$proto]($api);
+        }
+
+        if ($proto == 'ec2') {
+            return new Parser\QueryParser($api, null, false);
+        }
+
+        throw new \UnexpectedValueException(
+            'Unknown protocol: ' . $api->getProtocol()
+        );
+    }
+
+    /**
+     * Get the full name of the service
+     *
+     * @return string
+     */
+    public function getServiceFullName()
+    {
+        return $this->definition['metadata']['serviceFullName'];
+    }
+
+    /**
+     * Get the service id
+     *
+     * @return string
+     */
+    public function getServiceId()
+    {
+        return $this->definition['metadata']['serviceId'];
+    }
+
+    /**
+     * Get the API version of the service
+     *
+     * @return string
+     */
+    public function getApiVersion()
+    {
+        return $this->definition['metadata']['apiVersion'];
+    }
+
+    /**
+     * Get the API version of the service
+     *
+     * @return string
+     */
+    public function getEndpointPrefix()
+    {
+        return $this->definition['metadata']['endpointPrefix'];
+    }
+
+    /**
+     * Get the signing name used by the service.
+     *
+     * @return string
+     */
+    public function getSigningName()
+    {
+        return $this->definition['metadata']['signingName']
+            ?: $this->definition['metadata']['endpointPrefix'];
+    }
+
+    /**
+     * Get the service name.
+     *
+     * @return string
+     */
+    public function getServiceName()
+    {
+        return $this->definition['metadata']['serviceIdentifier'] ?? null;
+    }
+
+    /**
+     * Get the default signature version of the service.
+     *
+     * Note: this method assumes "v4" when not specified in the model.
+     *
+     * @return string
+     */
+    public function getSignatureVersion()
+    {
+        return $this->definition['metadata']['signatureVersion'] ?: 'v4';
+    }
+
+    /**
+     * Get the protocol used by the service.
+     *
+     * @return string
+     */
+    public function getProtocol()
+    {
+        return $this->protocol;
+    }
+
+    /**
+     * Get the uid string used by the service
+     *
+     * @return string
+     */
+    public function getUid()
+    {
+        return $this->definition['metadata']['uid'];
+    }
+
+    /**
+     * Check if the description has a specific operation by name.
+     *
+     * @param string $name Operation to check by name
+     *
+     * @return bool
+     */
+    public function hasOperation($name)
+    {
+        return isset($this['operations'][$name]);
+    }
+
+    /**
+     * Get an operation by name.
+     *
+     * @param string $name Operation to retrieve by name
+     *
+     * @return Operation
+     * @throws \InvalidArgumentException If the operation is not found
+     */
+    public function getOperation($name)
+    {
+        if (!isset($this->operations[$name])) {
+            if (!isset($this->definition['operations'][$name])) {
+                throw new \InvalidArgumentException("Unknown operation: $name");
+            }
+            $this->operations[$name] = new Operation(
+                $this->definition['operations'][$name],
+                $this->shapeMap
+            );
+        } elseif ($this->modifiedModel) {
+            $this->operations[$name] = new Operation(
+                $this->definition['operations'][$name],
+                $this->shapeMap
+            );
+        }
+
+        return $this->operations[$name];
+    }
+
+    /**
+     * Get all of the operations of the description.
+     *
+     * @return Operation[]
+     */
+    public function getOperations()
+    {
+        $result = [];
+        foreach ($this->definition['operations'] as $name => $definition) {
+            $result[$name] = $this->getOperation($name);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Get all of the error shapes of the service
+     *
+     * @return array
+     */
+    public function getErrorShapes()
+    {
+        $result = [];
+        foreach ($this->definition['shapes'] as $name => $definition) {
+            if (!empty($definition['exception'])) {
+                $definition['name'] = $name;
+                $result[] = new StructureShape($definition, $this->getShapeMap());
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Get all of the service metadata or a specific metadata key value.
+     *
+     * @param string|null $key Key to retrieve or null to retrieve all metadata
+     *
+     * @return mixed Returns the result or null if the key is not found
+     */
+    public function getMetadata($key = null)
+    {
+        if (!$key) {
+            return $this['metadata'];
+        }
+
+        if (isset($this->definition['metadata'][$key])) {
+            return $this->definition['metadata'][$key];
+        }
+
+        return null;
+    }
+
+    /**
+     * Gets an associative array of available paginator configurations where
+     * the key is the name of the paginator, and the value is the paginator
+     * configuration.
+     *
+     * @return array
+     * @unstable The configuration format of paginators may change in the future
+     */
+    public function getPaginators()
+    {
+        if (!isset($this->paginators)) {
+            $res = call_user_func(
+                $this->apiProvider,
+                'paginator',
+                $this->serviceName,
+                $this->apiVersion
+            );
+            $this->paginators = isset($res['pagination'])
+                ? $res['pagination']
+                : [];
+        }
+
+        return $this->paginators;
+    }
+
+    /**
+     * Determines if the service has a paginator by name.
+     *
+     * @param string $name Name of the paginator.
+     *
+     * @return bool
+     */
+    public function hasPaginator($name)
+    {
+        return isset($this->getPaginators()[$name]);
+    }
+
+    /**
+     * Retrieve a paginator by name.
+     *
+     * @param string $name Paginator to retrieve by name. This argument is
+     *                     typically the operation name.
+     * @return array
+     * @throws \UnexpectedValueException if the paginator does not exist.
+     * @unstable The configuration format of paginators may change in the future
+     */
+    public function getPaginatorConfig($name)
+    {
+        static $defaults = [
+            'input_token'  => null,
+            'output_token' => null,
+            'limit_key'    => null,
+            'result_key'   => null,
+            'more_results' => null,
+        ];
+
+        if ($this->hasPaginator($name)) {
+            return $this->paginators[$name] + $defaults;
+        }
+
+        throw new \UnexpectedValueException("There is no {$name} "
+            . "paginator defined for the {$this->serviceName} service.");
+    }
+
+    /**
+     * Gets an associative array of available waiter configurations where the
+     * key is the name of the waiter, and the value is the waiter
+     * configuration.
+     *
+     * @return array
+     */
+    public function getWaiters()
+    {
+        if (!isset($this->waiters)) {
+            $res = call_user_func(
+                $this->apiProvider,
+                'waiter',
+                $this->serviceName,
+                $this->apiVersion
+            );
+            $this->waiters = isset($res['waiters'])
+                ? $res['waiters']
+                : [];
+        }
+
+        return $this->waiters;
+    }
+
+    /**
+     * Determines if the service has a waiter by name.
+     *
+     * @param string $name Name of the waiter.
+     *
+     * @return bool
+     */
+    public function hasWaiter($name)
+    {
+        return isset($this->getWaiters()[$name]);
+    }
+
+    /**
+     * Get a waiter configuration by name.
+     *
+     * @param string $name Name of the waiter by name.
+     *
+     * @return array
+     * @throws \UnexpectedValueException if the waiter does not exist.
+     */
+    public function getWaiterConfig($name)
+    {
+        // Error if the waiter is not defined
+        if ($this->hasWaiter($name)) {
+            return $this->waiters[$name];
+        }
+
+        throw new \UnexpectedValueException("There is no {$name} waiter "
+            . "defined for the {$this->serviceName} service.");
+    }
+
+    /**
+     * Get the shape map used by the API.
+     *
+     * @return ShapeMap
+     */
+    public function getShapeMap()
+    {
+        return $this->shapeMap;
+    }
+
+    /**
+     * Get all the context params of the description.
+     *
+     * @return array
+     */
+    public function getClientContextParams()
+    {
+        return $this->clientContextParams;
+    }
+
+    /**
+     * Get the service's api provider.
+     *
+     * @return callable
+     */
+    public function getProvider()
+    {
+        return $this->apiProvider;
+    }
+
+    /**
+     * Get the service's definition.
+     *
+     * @return callable
+     */
+    public function getDefinition()
+    {
+        return $this->definition;
+    }
+
+    /**
+     * Sets the service's api definition.
+     * Intended for internal use only.
+     *
+     * @return void
+     *
+     * @internal
+     */
+    public function setDefinition($definition)
+    {
+        $this->definition = $definition;
+        $this->shapeMap = new ShapeMap($definition['shapes']);
+        $this->modifiedModel = true;
+    }
+
+    /**
+     * Denotes whether or not a service's definition has
+     * been modified.  Intended for internal use only.
+     *
+     * @return bool
+     *
+     * @internal
+     */
+    public function isModifiedModel()
+    {
+        return $this->modifiedModel;
+    }
+
+    /**
+     * Accepts a list of protocols derived from the service model.
+     * Returns the highest priority compatible auth scheme if the `protocols` trait is present.
+     * Otherwise, returns the value of the `protocol` field, if set, or null.
+     *
+     * @param array $definition
+     *
+     * @return string|null
+     */
+    private function selectProtocol(array $definition): string | null
+    {
+        $modeledProtocols = $definition['metadata']['protocols'] ?? null;
+        if (!empty($modeledProtocols)) {
+            foreach(SupportedProtocols::cases() as $protocol) {
+                if (in_array($protocol->value, $modeledProtocols)) {
+                    return $protocol->value;
+                }
+            }
+        }
+
+        return $definition['metadata']['protocol'] ?? null;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Shape.php

@@ -0,0 +1,77 @@
+<?php
+namespace Aws\Api;
+
+/**
+ * Base class representing a modeled shape.
+ */
+class Shape extends AbstractModel
+{
+    /**
+     * Get a concrete shape for the given definition.
+     *
+     * @param array    $definition
+     * @param ShapeMap $shapeMap
+     *
+     * @return mixed
+     * @throws \RuntimeException if the type is invalid
+     */
+    public static function create(array $definition, ShapeMap $shapeMap)
+    {
+        static $map = [
+            'structure' => StructureShape::class,
+            'map'       => MapShape::class,
+            'list'      => ListShape::class,
+            'timestamp' => TimestampShape::class,
+            'integer'   => Shape::class,
+            'double'    => Shape::class,
+            'float'     => Shape::class,
+            'long'      => Shape::class,
+            'string'    => Shape::class,
+            'byte'      => Shape::class,
+            'character' => Shape::class,
+            'blob'      => Shape::class,
+            'boolean'   => Shape::class
+        ];
+
+        if (isset($definition['shape'])) {
+            return $shapeMap->resolve($definition);
+        }
+
+        if (!isset($map[$definition['type']])) {
+            throw new \RuntimeException('Invalid type: '
+                . print_r($definition, true));
+        }
+
+        $type = $map[$definition['type']];
+
+        return new $type($definition, $shapeMap);
+    }
+
+    /**
+     * Get the type of the shape
+     *
+     * @return string
+     */
+    public function getType()
+    {
+        return $this->definition['type'];
+    }
+
+    /**
+     * Get the name of the shape
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->definition['name'];
+    }
+
+    /**
+     * Get a context param definition.
+     */
+    public function getContextParam()
+    {
+        return $this->contextParam;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/ShapeMap.php

@@ -0,0 +1,109 @@
+<?php
+namespace Aws\Api;
+
+/**
+ * Builds shape based on shape references.
+ */
+class ShapeMap implements \ArrayAccess
+{
+    /** @var array */
+    private $definitions;
+
+    /** @var Shape[] */
+    private $simple;
+
+    /**
+     * @param array $shapeModels Associative array of shape definitions.
+     */
+    public function __construct(array $shapeModels)
+    {
+        $this->definitions = $shapeModels;
+    }
+
+    /**
+     * Get an array of shape names.
+     *
+     * @return array
+     */
+    public function getShapeNames()
+    {
+        return array_keys($this->definitions);
+    }
+
+    /**
+     * Resolve a shape reference
+     *
+     * @param array $shapeRef Shape reference shape
+     *
+     * @return Shape
+     * @throws \InvalidArgumentException
+     */
+    public function resolve(array $shapeRef)
+    {
+        $shape = $shapeRef['shape'];
+
+        if (!isset($this->definitions[$shape])) {
+            throw new \InvalidArgumentException('Shape not found: ' . $shape);
+        }
+
+        $isSimple = count($shapeRef) == 1;
+        if ($isSimple && isset($this->simple[$shape])) {
+            return $this->simple[$shape];
+        }
+
+        $definition = $shapeRef + $this->definitions[$shape];
+        $definition['name'] = $definition['shape'];
+        if (isset($definition['shape'])) {
+            unset($definition['shape']);
+        }
+
+        $result = Shape::create($definition, $this);
+
+        if ($isSimple) {
+            $this->simple[$shape] = $result;
+        }
+
+        return $result;
+    }
+
+    /**
+     * @param mixed $offset
+     * @return bool
+     */
+    public function offsetExists(mixed $offset): bool
+    {
+        return isset($this->definitions[$offset]);
+    }
+
+    /**
+     * @param mixed $offset
+     * @return mixed
+     */
+    public function offsetGet(mixed $offset): mixed
+    {
+        return $this->definitions[$offset] ?? null;
+    }
+
+    /**
+     * @param mixed $offset
+     * @param mixed $value
+     * @throws \BadMethodCallException
+     */
+    public function offsetSet(mixed $offset, mixed $value): void
+    {
+        throw new \BadMethodCallException(
+            'ShapeMap is read-only and cannot be modified.'
+        );
+    }
+
+    /**
+     * @param mixed $offset
+     * @throws \BadMethodCallException
+     */
+    public function offsetUnset(mixed $offset): void
+    {
+        throw new \BadMethodCallException(
+            'ShapeMap is read-only and cannot be modified.'
+        );
+    }
+}

vendor/aws/aws-sdk-php/src/Api/StructureShape.php

@@ -0,0 +1,105 @@
+<?php
+namespace Aws\Api;
+
+/**
+ * Represents a structure shape and resolve member shape references.
+ */
+class StructureShape extends Shape
+{
+    /**
+     * @var Shape[]
+     */
+    private $members;
+
+    public function __construct(array $definition, ShapeMap $shapeMap)
+    {
+        $definition['type'] = 'structure';
+
+        if (!isset($definition['members'])) {
+            $definition['members'] = [];
+        }
+
+        parent::__construct($definition, $shapeMap);
+    }
+
+    /**
+     * Gets a list of all members
+     *
+     * @return Shape[]
+     */
+    public function getMembers()
+    {
+        if (empty($this->members)) {
+            $this->generateMembersHash();
+        }
+
+        return $this->members;
+    }
+
+    /**
+     * Check if a specific member exists by name.
+     *
+     * @param string $name Name of the member to check
+     *
+     * @return bool
+     */
+    public function hasMember($name)
+    {
+        return isset($this->definition['members'][$name]);
+    }
+
+    /**
+     * Retrieve a member by name.
+     *
+     * @param string $name Name of the member to retrieve
+     *
+     * @return Shape
+     * @throws \InvalidArgumentException if the member is not found.
+     */
+    public function getMember($name)
+    {
+        $members = $this->getMembers();
+
+        if (!isset($members[$name])) {
+            throw new \InvalidArgumentException('Unknown member ' . $name);
+        }
+
+        return $members[$name];
+    }
+
+    /**
+     * Used to look up the shape's original definition.
+     * ShapeMap::resolve() merges properties from both
+     * member and target shape definitions, causing certain
+     * properties like `locationName` to be overwritten.
+     *
+     * @return ShapeMap
+     * @internal This method is for internal use only and should not be used
+     * by external code. It may be changed or removed without notice.
+     */
+    public function getShapeMap(): ShapeMap
+    {
+        return $this->shapeMap;
+    }
+
+    /**
+     * Used to look up a shape's original definition.
+     *
+     * @param string $name
+     *
+     * @return array|null
+     */
+    public function getOriginalDefinition(string $name): ?array
+    {
+        return $this->shapeMap[$name] ?? null;
+    }
+
+    private function generateMembersHash()
+    {
+        $this->members = [];
+
+        foreach ($this->definition['members'] as $name => $definition) {
+            $this->members[$name] = $this->shapeFor($definition);
+        }
+    }
+}

vendor/aws/aws-sdk-php/src/Api/SupportedProtocols.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Aws\Api;
+
+/**
+ * Priority ordered collection of supported AWS protocols.
+ */
+enum SupportedProtocols: string
+{
+    case JSON = 'json';
+    case REST_JSON = 'rest-json';
+    case REST_XML = 'rest-xml';
+    case QUERY = 'query';
+    case EC2 = 'ec2';
+
+    /**
+     * Check if a protocol is valid.
+     *
+     * @param string $protocol
+     * @return bool True if the protocol is supported, otherwise false.
+     */
+    public static function isSupported(string $protocol): bool
+    {
+        return self::tryFrom($protocol) !== null;
+    }
+}

vendor/aws/aws-sdk-php/src/Api/TimestampShape.php

@@ -0,0 +1,48 @@
+<?php
+namespace Aws\Api;
+
+/**
+ * Represents a timestamp shape.
+ */
+class TimestampShape extends Shape
+{
+    public function __construct(array $definition, ShapeMap $shapeMap)
+    {
+        $definition['type'] = 'timestamp';
+        parent::__construct($definition, $shapeMap);
+    }
+
+    /**
+     * Formats a timestamp value for a service.
+     *
+     * @param mixed  $value  Value to format
+     * @param string $format Format used to serialize the value
+     *
+     * @return int|string
+     * @throws \UnexpectedValueException if the format is unknown.
+     * @throws \InvalidArgumentException if the value is an unsupported type.
+     */
+    public static function format($value, $format)
+    {
+        if ($value instanceof \DateTimeInterface) {
+            $value = $value->getTimestamp();
+        } elseif (is_string($value)) {
+            $value = strtotime($value);
+        } elseif (!is_int($value)) {
+            throw new \InvalidArgumentException('Unable to handle the provided'
+                . ' timestamp type: ' . gettype($value));
+        }
+
+        switch ($format) {
+            case 'iso8601':
+                return gmdate('Y-m-d\TH:i:s\Z', $value);
+            case 'rfc822':
+                return gmdate('D, d M Y H:i:s \G\M\T', $value);
+            case 'unixTimestamp':
+                return $value;
+            default:
+                throw new \UnexpectedValueException('Unknown timestamp format: '
+                    . $format);
+        }
+    }
+}

vendor/aws/aws-sdk-php/src/Api/Validator.php

@@ -0,0 +1,336 @@
+<?php
+namespace Aws\Api;
+
+use Aws;
+
+/**
+ * Validates a schema against a hash of input.
+ */
+class Validator
+{
+    private $path = [];
+    private $errors = [];
+    private $constraints = [];
+
+    private static $defaultConstraints = [
+        'required' => true,
+        'min'      => true,
+        'max'      => false,
+        'pattern'  => false
+    ];
+
+    /**
+     * @param array $constraints Associative array of constraints to enforce.
+     *                           Accepts the following keys: "required", "min",
+     *                           "max", and "pattern". If a key is not
+     *                           provided, the constraint will assume false.
+     */
+    public function __construct(?array $constraints = null)
+    {
+        static $assumedFalseValues = [
+            'required' => false,
+            'min'      => false,
+            'max'      => false,
+            'pattern'  => false
+        ];
+        $this->constraints = empty($constraints)
+            ? self::$defaultConstraints
+            : $constraints + $assumedFalseValues;
+    }
+
+    /**
+     * Validates the given input against the schema.
+     *
+     * @param string $name  Operation name
+     * @param Shape  $shape Shape to validate
+     * @param array  $input Input to validate
+     *
+     * @throws \InvalidArgumentException if the input is invalid.
+     */
+    public function validate($name, Shape $shape, array $input)
+    {
+        $this->dispatch($shape, $input);
+
+        if ($this->errors) {
+            $message = sprintf(
+                "Found %d error%s while validating the input provided for the "
+                    . "%s operation:\n%s",
+                count($this->errors),
+                count($this->errors) > 1 ? 's' : '',
+                $name,
+                implode("\n", $this->errors)
+            );
+            $this->errors = [];
+
+            throw new \InvalidArgumentException($message);
+        }
+    }
+
+    private function dispatch(Shape $shape, $value)
+    {
+        static $methods = [
+            'structure' => 'check_structure',
+            'list'      => 'check_list',
+            'map'       => 'check_map',
+            'blob'      => 'check_blob',
+            'boolean'   => 'check_boolean',
+            'integer'   => 'check_numeric',
+            'float'     => 'check_numeric',
+            'long'      => 'check_numeric',
+            'string'    => 'check_string',
+            'byte'      => 'check_string',
+            'char'      => 'check_string'
+        ];
+
+        $type = $shape->getType();
+        if (isset($methods[$type])) {
+            $this->{$methods[$type]}($shape, $value);
+        }
+    }
+
+    private function check_structure(StructureShape $shape, $value)
+    {
+        $isDocument = (isset($shape['document']) && $shape['document']);
+        $isUnion = (isset($shape['union']) && $shape['union']);
+        if ($isDocument) {
+            if (!$this->checkDocumentType($value)) {
+                $this->addError("is not a valid document type");
+                return;
+            }
+        } elseif ($isUnion) {
+            if (!$this->checkUnion($value)) {
+                $this->addError("is a union type and must have exactly one non null value");
+                return;
+            }
+        } elseif (!$this->checkAssociativeArray($value)) {
+            return;
+        }
+
+        if ($this->constraints['required'] && $shape['required']) {
+            foreach ($shape['required'] as $req) {
+                if (!isset($value[$req])) {
+                    $this->path[] = $req;
+                    $this->addError('is missing and is a required parameter');
+                    array_pop($this->path);
+                }
+            }
+        }
+        if (!$isDocument) {
+            foreach ($value as $name => $v) {
+                if ($shape->hasMember($name)) {
+                    $this->path[] = $name;
+                    $this->dispatch(
+                        $shape->getMember($name),
+                        isset($value[$name]) ? $value[$name] : null
+                    );
+                    array_pop($this->path);
+                }
+            }
+        }
+    }
+
+    private function check_list(ListShape $shape, $value)
+    {
+        if (!is_array($value)) {
+            $this->addError('must be an array. Found '
+                . Aws\describe_type($value));
+            return;
+        }
+
+        $this->validateRange($shape, count($value), "list element count");
+
+        $items = $shape->getMember();
+        foreach ($value as $index => $v) {
+            $this->path[] = $index;
+            $this->dispatch($items, $v);
+            array_pop($this->path);
+        }
+    }
+
+    private function check_map(MapShape $shape, $value)
+    {
+        if (!$this->checkAssociativeArray($value)) {
+            return;
+        }
+
+        $values = $shape->getValue();
+        foreach ($value as $key => $v) {
+            $this->path[] = $key;
+            $this->dispatch($values, $v);
+            array_pop($this->path);
+        }
+    }
+
+    private function check_blob(Shape $shape, $value)
+    {
+        static $valid = [
+            'string' => true,
+            'integer' => true,
+            'double' => true,
+            'resource' => true
+        ];
+
+        $type = gettype($value);
+        if (!isset($valid[$type])) {
+            if ($type != 'object' || !method_exists($value, '__toString')) {
+                $this->addError('must be an fopen resource, a '
+                    . 'GuzzleHttp\Stream\StreamInterface object, or something '
+                    . 'that can be cast to a string. Found '
+                    . Aws\describe_type($value));
+            }
+        }
+    }
+
+    private function check_numeric(Shape $shape, $value)
+    {
+        if (!is_numeric($value)) {
+            $this->addError('must be numeric. Found '
+                . Aws\describe_type($value));
+            return;
+        }
+
+        $this->validateRange($shape, $value, "numeric value");
+    }
+
+    private function check_boolean(Shape $shape, $value)
+    {
+        if (!is_bool($value)) {
+            $this->addError('must be a boolean. Found '
+                . Aws\describe_type($value));
+        }
+    }
+
+    private function check_string(Shape $shape, $value)
+    {
+        if ($shape['jsonvalue']) {
+            if (!self::canJsonEncode($value)) {
+                $this->addError('must be a value encodable with \'json_encode\'.'
+                    . ' Found ' . Aws\describe_type($value));
+            }
+            return;
+        }
+
+        if (!$this->checkCanString($value)) {
+            $this->addError('must be a string or an object that implements '
+                . '__toString(). Found ' . Aws\describe_type($value));
+            return;
+        }
+
+        $value = isset($value) ? $value : '';
+        $this->validateRange($shape, strlen($value), "string length");
+
+        if ($this->constraints['pattern']) {
+            $pattern = $shape['pattern'];
+            if ($pattern && !preg_match("/$pattern/", $value)) {
+                $this->addError("Pattern /$pattern/ failed to match '$value'");
+            }
+        }
+    }
+
+    private function validateRange(Shape $shape, $length, $descriptor)
+    {
+        if ($this->constraints['min']) {
+            $min = $shape['min'];
+            if ($min && $length < $min) {
+                $this->addError("expected $descriptor to be >= $min, but "
+                    . "found $descriptor of $length");
+            }
+        }
+
+        if ($this->constraints['max']) {
+            $max = $shape['max'];
+            if ($max && $length > $max) {
+                $this->addError("expected $descriptor to be <= $max, but "
+                    . "found $descriptor of $length");
+            }
+        }
+    }
+
+    private function checkArray($arr)
+    {
+        return array_is_list($arr) || Aws\is_associative($arr);
+    }
+
+    private function checkCanString($value)
+    {
+        static $valid = [
+            'string'  => true,
+            'integer' => true,
+            'double'  => true,
+            'NULL'    => true,
+        ];
+
+        $type = gettype($value);
+
+        return isset($valid[$type]) ||
+            ($type == 'object' && method_exists($value, '__toString'));
+    }
+
+    private function checkAssociativeArray($value)
+    {
+        $isAssociative = false;
+
+        if (is_array($value)) {
+            $expectedIndex = 0;
+            $key = key($value);
+
+            do {
+                $isAssociative = $key !== $expectedIndex++;
+                next($value);
+                $key = key($value);
+            } while (!$isAssociative && null !== $key);
+        }
+
+        if (!$isAssociative) {
+            $this->addError('must be an associative array. Found '
+                . Aws\describe_type($value));
+            return false;
+        }
+
+        return true;
+    }
+
+    private function checkDocumentType($value)
+    {
+        if (is_array($value)) {
+            $typeOfFirstKey = gettype(key($value));
+            foreach ($value as $key => $val) {
+               if (!$this->checkDocumentType($val) || gettype($key) != $typeOfFirstKey) {
+                   return false;
+               }
+            }
+            return $this->checkArray($value);
+        }
+        return is_null($value)
+            || is_numeric($value)
+            || is_string($value)
+            || is_bool($value);
+    }
+
+    private function checkUnion($value)
+    {
+        if (is_array($value)) {
+            $nonNullCount = 0;
+            foreach ($value as $key => $val) {
+                if (!is_null($val) && !(strpos($key, "@") === 0)) {
+                    $nonNullCount++;
+                }
+            }
+            return $nonNullCount == 1;
+        }
+        return !is_null($value);
+    }
+
+    private function addError($message)
+    {
+        $this->errors[] =
+            implode('', array_map(function ($s) { return "[{$s}]"; }, $this->path))
+            . ' '
+            . $message;
+    }
+
+    private function canJsonEncode($data)
+    {
+        return !is_resource($data);
+    }
+}

vendor/aws/aws-sdk-php/src/Arn/AccessPointArn.php

@@ -0,0 +1,66 @@
+<?php
+namespace Aws\Arn;
+
+use Aws\Arn\Exception\InvalidArnException;
+
+/**
+ * @internal
+ */
+class AccessPointArn extends Arn implements AccessPointArnInterface
+{
+    use ResourceTypeAndIdTrait;
+
+    /**
+     * AccessPointArn constructor
+     *
+     * @param $data
+     */
+    public function __construct($data)
+    {
+        parent::__construct($data);
+        static::validate($this->data);
+    }
+
+    public static function parse($string)
+    {
+        $data = parent::parse($string);
+        $data = self::parseResourceTypeAndId($data);
+        $data['accesspoint_name'] = $data['resource_id'];
+        return $data;
+    }
+
+    public function getAccesspointName()
+    {
+        return $this->data['accesspoint_name'];
+    }
+
+    /**
+     * Validation specific to AccessPointArn
+     *
+     * @param array $data
+     */
+    protected static function validate(array $data)
+    {
+        self::validateRegion($data, 'access point ARN');
+        self::validateAccountId($data, 'access point ARN');
+
+        if ($data['resource_type'] !== 'accesspoint') {
+            throw new InvalidArnException("The 6th component of an access point ARN"
+                . " represents the resource type and must be 'accesspoint'.");
+        }
+
+        if (empty($data['resource_id'])) {
+            throw new InvalidArnException("The 7th component of an access point ARN"
+                . " represents the resource ID and must not be empty.");
+        }
+        if (strpos($data['resource_id'], ':') !== false) {
+            throw new InvalidArnException("The resource ID component of an access"
+                . " point ARN must not contain additional components"
+                . " (delimited by ':').");
+        }
+        if (!self::isValidHostLabel($data['resource_id'])) {
+            throw new InvalidArnException("The resource ID in an access point ARN"
+                . " must be a valid host label value.");
+        }
+    }
+}

vendor/aws/aws-sdk-php/src/Arn/AccessPointArnInterface.php

@@ -0,0 +1,10 @@
+<?php
+namespace Aws\Arn;
+
+/**
+ * @internal
+ */
+interface AccessPointArnInterface extends ArnInterface
+{
+    public function getAccesspointName();
+}

vendor/aws/aws-sdk-php/src/Arn/Arn.php

@@ -0,0 +1,188 @@
+<?php
+namespace Aws\Arn;
+
+use Aws\Arn\Exception\InvalidArnException;
+
+/**
+ * Amazon Resource Names (ARNs) uniquely identify AWS resources. The Arn class
+ * parses and stores a generic ARN object representation that can apply to any
+ * service resource.
+ *
+ * @internal
+ */
+class Arn implements ArnInterface
+{
+    protected $data;
+    protected $string;
+
+    public static function parse($string)
+    {
+        $data = [
+            'arn' => null,
+            'partition' => null,
+            'service' => null,
+            'region' => null,
+            'account_id' => null,
+            'resource' => null,
+        ];
+
+        $length = strlen($string);
+        $lastDelim = 0;
+        $numComponents = 0;
+        for ($i = 0; $i < $length; $i++) {
+
+            if (($numComponents < 5 && $string[$i] === ':')) {
+                // Split components between delimiters
+                $data[key($data)] = substr($string, $lastDelim, $i - $lastDelim);
+
+                // Do not include delimiter character itself
+                $lastDelim = $i + 1;
+                next($data);
+                $numComponents++;
+            }
+
+            if ($i === $length - 1) {
+                // Put the remainder in the last component.
+                if (in_array($numComponents, [5])) {
+                    $data['resource'] = substr($string, $lastDelim);
+                } else {
+                    // If there are < 5 components, put remainder in current
+                    // component.
+                    $data[key($data)] = substr($string, $lastDelim);
+                }
+            }
+        }
+
+        return $data;
+    }
+
+    public function __construct($data)
+    {
+        if (is_array($data)) {
+            $this->data = $data;
+        } elseif (is_string($data)) {
+            $this->data = static::parse($data);
+        } else {
+            throw new InvalidArnException('Constructor accepts a string or an'
+                . ' array as an argument.');
+        }
+
+        static::validate($this->data);
+    }
+
+    public function __toString()
+    {
+        if (!isset($this->string)) {
+            $components = [
+                $this->getPrefix(),
+                $this->getPartition(),
+                $this->getService(),
+                $this->getRegion(),
+                $this->getAccountId(),
+                $this->getResource(),
+            ];
+
+            $this->string = implode(':', $components);
+        }
+        return $this->string;
+    }
+
+    public function getPrefix()
+    {
+        return $this->data['arn'];
+    }
+
+    public function getPartition()
+    {
+        return $this->data['partition'];
+    }
+
+    public function getService()
+    {
+        return $this->data['service'];
+    }
+
+    public function getRegion()
+    {
+        return $this->data['region'];
+    }
+
+    public function getAccountId()
+    {
+        return $this->data['account_id'];
+    }
+
+    public function getResource()
+    {
+        return $this->data['resource'];
+    }
+
+    public function toArray()
+    {
+        return $this->data;
+    }
+
+    /**
+     * Minimally restrictive generic ARN validation
+     *
+     * @param array $data
+     */
+    protected static function validate(array $data)
+    {
+        if ($data['arn'] !== 'arn') {
+            throw new InvalidArnException("The 1st component of an ARN must be"
+                . " 'arn'.");
+        }
+
+        if (empty($data['partition'])) {
+            throw new InvalidArnException("The 2nd component of an ARN"
+                . " represents the partition and must not be empty.");
+        }
+
+        if (empty($data['service'])) {
+            throw new InvalidArnException("The 3rd component of an ARN"
+                . " represents the service and must not be empty.");
+        }
+
+        if (empty($data['resource'])) {
+            throw new InvalidArnException("The 6th component of an ARN"
+                . " represents the resource information and must not be empty."
+                . " Individual service ARNs may include additional delimiters"
+                . " to further qualify resources.");
+        }
+    }
+
+    protected static function validateAccountId($data, $arnName)
+    {
+        if (!self::isValidHostLabel($data['account_id'])) {
+            throw new InvalidArnException("The 5th component of a {$arnName}"
+                . " is required, represents the account ID, and"
+                . " must be a valid host label.");
+        }
+    }
+
+    protected static function validateRegion($data, $arnName)
+    {
+        if (empty($data['region'])) {
+            throw new InvalidArnException("The 4th component of a {$arnName}"
+                . " represents the region and must not be empty.");
+        }
+    }
+
+    /**
+     * Validates whether a string component is a valid host label
+     *
+     * @param $string
+     * @return bool
+     */
+    protected static function isValidHostLabel($string)
+    {
+        if (empty($string) || strlen($string) > 63) {
+            return false;
+        }
+        if ($value = preg_match("/^[a-zA-Z0-9-]+$/", $string)) {
+            return true;
+        }
+        return false;
+    }
+}

vendor/aws/aws-sdk-php/src/Arn/ArnInterface.php

@@ -0,0 +1,37 @@
+<?php
+namespace Aws\Arn;
+
+/**
+ * Amazon Resource Names (ARNs) uniquely identify AWS resources. Classes
+ * implementing ArnInterface parse and store an ARN object representation.
+ *
+ * Valid ARN formats include:
+ *
+ *   arn:partition:service:region:account-id:resource-id
+ *   arn:partition:service:region:account-id:resource-type/resource-id
+ *   arn:partition:service:region:account-id:resource-type:resource-id
+ *
+ * Some components may be omitted, depending on the service and resource type.
+ *
+ * @internal
+ */
+interface ArnInterface
+{
+    public static function parse($string);
+
+    public function __toString();
+
+    public function getPrefix();
+
+    public function getPartition();
+
+    public function getService();
+
+    public function getRegion();
+
+    public function getAccountId();
+
+    public function getResource();
+
+    public function toArray();
+}

vendor/aws/aws-sdk-php/src/Arn/ArnParser.php

@@ -0,0 +1,69 @@
+<?php
+namespace Aws\Arn;
+
+use Aws\Arn\S3\AccessPointArn as S3AccessPointArn;
+use Aws\Arn\ObjectLambdaAccessPointArn;
+use Aws\Arn\S3\MultiRegionAccessPointArn;
+use Aws\Arn\S3\OutpostsBucketArn;
+use Aws\Arn\S3\RegionalBucketArn;
+use Aws\Arn\S3\OutpostsAccessPointArn;
+
+/**
+ * This class provides functionality to parse ARN strings and return a
+ * corresponding ARN object. ARN-parsing logic may be subject to change in the
+ * future, so this should not be relied upon for external customer usage.
+ *
+ * @internal
+ */
+class ArnParser
+{
+    /**
+     * @param $string
+     * @return bool
+     */
+    public static function isArn($string)
+    {
+        return $string !== null && strpos($string, 'arn:') === 0;
+    }
+
+    /**
+     * Parses a string and returns an instance of ArnInterface. Returns a
+     * specific type of Arn object if it has a specific class representation
+     * or a generic Arn object if not.
+     *
+     * @param $string
+     * @return ArnInterface
+     */
+    public static function parse($string)
+    {
+        $data = Arn::parse($string);
+        if ($data['service'] === 's3-object-lambda') {
+            return new ObjectLambdaAccessPointArn($string);
+        }
+        $resource = self::explodeResourceComponent($data['resource']);
+        if ($resource[0] === 'outpost') {
+            if (isset($resource[2]) && $resource[2] === 'bucket') {
+                return new OutpostsBucketArn($string);
+            }
+            if (isset($resource[2]) && $resource[2] === 'accesspoint') {
+                return new OutpostsAccessPointArn($string);
+            }
+        }
+        if (empty($data['region'])) {
+            return new MultiRegionAccessPointArn($string);
+        }
+        if ($resource[0] === 'accesspoint') {
+            if ($data['service'] === 's3') {
+                return new S3AccessPointArn($string);
+            }
+            return new AccessPointArn($string);
+        }
+
+        return new Arn($data);
+    }
+
+    private static function explodeResourceComponent($resource)
+    {
+        return preg_split("/[\/:]/", $resource);
+    }
+}

vendor/aws/aws-sdk-php/src/Arn/Exception/InvalidArnException.php

@@ -0,0 +1,7 @@
+<?php
+namespace Aws\Arn\Exception;
+
+/**
+ * Represents a failed attempt to construct an Arn
+ */
+class InvalidArnException extends \RuntimeException {}

vendor/aws/aws-sdk-php/src/Arn/ObjectLambdaAccessPointArn.php

@@ -0,0 +1,35 @@
+<?php
+namespace Aws\Arn;
+
+/**
+ * This class represents an S3 Object bucket ARN, which is in the
+ * following format:
+ *
+ * @internal
+ */
+class ObjectLambdaAccessPointArn extends AccessPointArn
+{
+    /**
+     * Parses a string into an associative array of components that represent
+     * a ObjectLambdaAccessPointArn
+     *
+     * @param $string
+     * @return array
+     */
+    public static function parse($string)
+    {
+        $data = parent::parse($string);
+        return parent::parseResourceTypeAndId($data);
+    }
+
+    /**
+     *
+     * @param array $data
+     */
+    protected static function validate(array $data)
+    {
+        parent::validate($data);
+        self::validateRegion($data, 'S3 Object Lambda ARN');
+        self::validateAccountId($data, 'S3 Object Lambda ARN');
+    }
+}

vendor/aws/aws-sdk-php/src/Arn/ResourceTypeAndIdTrait.php

@@ -0,0 +1,30 @@
+<?php
+namespace Aws\Arn;
+
+/**
+ * @internal
+ */
+trait ResourceTypeAndIdTrait
+{
+    public function getResourceType()
+    {
+        return $this->data['resource_type'];
+    }
+
+    public function getResourceId()
+    {
+        return $this->data['resource_id'];
+    }
+
+    protected static function parseResourceTypeAndId(array $data)
+    {
+        $resourceData = preg_split("/[\/:]/", $data['resource'], 2);
+        $data['resource_type'] = isset($resourceData[0])
+            ? $resourceData[0]
+            : null;
+        $data['resource_id'] = isset($resourceData[1])
+            ? $resourceData[1]
+            : null;
+        return $data;
+    }
+}

vendor/aws/aws-sdk-php/src/Arn/S3/AccessPointArn.php

@@ -0,0 +1,27 @@
+<?php
+namespace Aws\Arn\S3;
+
+use Aws\Arn\AccessPointArn as BaseAccessPointArn;
+use Aws\Arn\AccessPointArnInterface;
+use Aws\Arn\ArnInterface;
+use Aws\Arn\Exception\InvalidArnException;
+
+/**
+ * @internal
+ */
+class AccessPointArn extends BaseAccessPointArn implements AccessPointArnInterface
+{
+    /**
+     * Validation specific to AccessPointArn
+     *
+     * @param array $data
+     */
+    public static function validate(array $data)
+    {
+        parent::validate($data);
+        if ($data['service'] !== 's3') {
+            throw new InvalidArnException("The 3rd component of an S3 access"
+                . " point ARN represents the region and must be 's3'.");
+        }
+    }
+}

vendor/aws/aws-sdk-php/src/Arn/S3/BucketArnInterface.php

@@ -0,0 +1,12 @@
+<?php
+namespace Aws\Arn\S3;
+
+use Aws\Arn\ArnInterface;
+
+/**
+ * @internal
+ */
+interface BucketArnInterface extends ArnInterface
+{
+    public function getBucketName();
+}

vendor/aws/aws-sdk-php/src/Arn/S3/MultiRegionAccessPointArn.php

@@ -0,0 +1,38 @@
+<?php
+namespace Aws\Arn\S3;
+
+use Aws\Arn\Arn;
+use Aws\Arn\ResourceTypeAndIdTrait;
+
+/**
+ * This class represents an S3 multi-region bucket ARN, which is in the
+ * following format:
+ *
+ * @internal
+ */
+class MultiRegionAccessPointArn extends AccessPointArn
+{
+    use ResourceTypeAndIdTrait;
+
+    /**
+     * Parses a string into an associative array of components that represent
+     * a MultiRegionArn
+     *
+     * @param $string
+     * @return array
+     */
+    public static function parse($string)
+    {
+        return parent::parse($string);
+    }
+
+    /**
+     *
+     * @param array $data
+     */
+    public static function validate(array $data)
+    {
+        Arn::validate($data);
+    }
+
+}

vendor/aws/aws-sdk-php/src/Arn/S3/OutpostsAccessPointArn.php

@@ -0,0 +1,110 @@
+<?php
+namespace Aws\Arn\S3;
+
+use Aws\Arn\AccessPointArn as BaseAccessPointArn;
+use Aws\Arn\AccessPointArnInterface;
+use Aws\Arn\Arn;
+use Aws\Arn\Exception\InvalidArnException;
+
+/**
+ * This class represents an S3 Outposts access point ARN, which is in the
+ * following format:
+ *
+ * arn:{partition}:s3-outposts:{region}:{accountId}:outpost:{outpostId}:accesspoint:{accesspointName}
+ *
+ * ':' and '/' can be used interchangeably as delimiters for components after
+ * the account ID.
+ *
+ * @internal
+ */
+class OutpostsAccessPointArn extends BaseAccessPointArn implements
+    AccessPointArnInterface,
+    OutpostsArnInterface
+{
+    public static function parse($string)
+    {
+        $data = parent::parse($string);
+        return self::parseOutpostData($data);
+    }
+
+    public function getOutpostId()
+    {
+        return $this->data['outpost_id'];
+    }
+
+    public function getAccesspointName()
+    {
+        return $this->data['accesspoint_name'];
+    }
+
+    private static function parseOutpostData(array $data)
+    {
+        $resourceData = preg_split("/[\/:]/", $data['resource_id']);
+
+        $data['outpost_id'] = isset($resourceData[0])
+            ? $resourceData[0]
+            : null;
+        $data['accesspoint_type'] = isset($resourceData[1])
+            ? $resourceData[1]
+            : null;
+        $data['accesspoint_name'] = isset($resourceData[2])
+            ? $resourceData[2]
+            : null;
+        if (isset($resourceData[3])) {
+            $data['resource_extra'] = implode(':', array_slice($resourceData, 3));
+        }
+
+        return $data;
+    }
+
+    /**
+     * Validation specific to OutpostsAccessPointArn. Note this uses the base Arn
+     * class validation instead of the direct parent due to it having slightly
+     * differing requirements from its parent.
+     *
+     * @param array $data
+     */
+    public static function validate(array $data)
+    {
+        Arn::validate($data);
+
+        if (($data['service'] !== 's3-outposts')) {
+            throw new InvalidArnException("The 3rd component of an S3 Outposts"
+                . " access point ARN represents the service and must be"
+                . " 's3-outposts'.");
+        }
+
+        self::validateRegion($data, 'S3 Outposts access point ARN');
+        self::validateAccountId($data, 'S3 Outposts access point ARN');
+
+        if (($data['resource_type'] !== 'outpost')) {
+            throw new InvalidArnException("The 6th component of an S3 Outposts"
+                . " access point ARN represents the resource type and must be"
+                . " 'outpost'.");
+        }
+
+        if (!self::isValidHostLabel($data['outpost_id'])) {
+            throw new InvalidArnException("The 7th component of an S3 Outposts"
+                . " access point ARN is required, represents the outpost ID, and"
+                . " must be a valid host label.");
+        }
+
+        if ($data['accesspoint_type'] !== 'accesspoint') {
+            throw new InvalidArnException("The 8th component of an S3 Outposts"
+                . " access point ARN must be 'accesspoint'");
+        }
+
+        if (!self::isValidHostLabel($data['accesspoint_name'])) {
+            throw new InvalidArnException("The 9th component of an S3 Outposts"
+                . " access point ARN is required, represents the accesspoint name,"
+                . " and must be a valid host label.");
+        }
+
+        if (!empty($data['resource_extra'])) {
+            throw new InvalidArnException("An S3 Outposts access point ARN"
+                . " should only have 9 components, delimited by the characters"
+                . " ':' and '/'. '{$data['resource_extra']}' was found after the"
+                . " 9th component.");
+        }
+    }
+}

vendor/aws/aws-sdk-php/src/Arn/S3/OutpostsArnInterface.php

@@ -0,0 +1,12 @@
+<?php
+namespace Aws\Arn\S3;
+
+use Aws\Arn\ArnInterface;
+
+/**
+ * @internal
+ */
+interface OutpostsArnInterface extends ArnInterface
+{
+    public function getOutpostId();
+}

vendor/aws/aws-sdk-php/src/Arn/S3/OutpostsBucketArn.php

@@ -0,0 +1,99 @@
+<?php
+namespace Aws\Arn\S3;
+
+use Aws\Arn\Arn;
+use Aws\Arn\Exception\InvalidArnException;
+use Aws\Arn\ResourceTypeAndIdTrait;
+
+/**
+ * This class represents an S3 Outposts bucket ARN, which is in the
+ * following format:
+ *
+ * @internal
+ */
+class OutpostsBucketArn extends Arn implements
+    BucketArnInterface,
+    OutpostsArnInterface
+{
+    use ResourceTypeAndIdTrait;
+
+    /**
+     * Parses a string into an associative array of components that represent
+     * a OutpostsBucketArn
+     *
+     * @param $string
+     * @return array
+     */
+    public static function parse($string)
+    {
+        $data = parent::parse($string);
+        $data = self::parseResourceTypeAndId($data);
+        return self::parseOutpostData($data);
+    }
+
+    public function getBucketName()
+    {
+        return $this->data['bucket_name'];
+    }
+
+    public function getOutpostId()
+    {
+        return $this->data['outpost_id'];
+    }
+
+    private static function parseOutpostData(array $data)
+    {
+        $resourceData = preg_split("/[\/:]/", $data['resource_id'], 3);
+
+        $data['outpost_id'] = isset($resourceData[0])
+            ? $resourceData[0]
+            : null;
+        $data['bucket_label'] = isset($resourceData[1])
+            ? $resourceData[1]
+            : null;
+        $data['bucket_name'] = isset($resourceData[2])
+            ? $resourceData[2]
+            : null;
+
+        return $data;
+    }
+
+    /**
+     *
+     * @param array $data
+     */
+    public static function validate(array $data)
+    {
+        Arn::validate($data);
+
+        if (($data['service'] !== 's3-outposts')) {
+            throw new InvalidArnException("The 3rd component of an S3 Outposts"
+                . " bucket ARN represents the service and must be 's3-outposts'.");
+        }
+
+        self::validateRegion($data, 'S3 Outposts bucket ARN');
+        self::validateAccountId($data, 'S3 Outposts bucket ARN');
+
+        if (($data['resource_type'] !== 'outpost')) {
+            throw new InvalidArnException("The 6th component of an S3 Outposts"
+                . " bucket ARN represents the resource type and must be"
+                . " 'outpost'.");
+        }
+
+        if (!self::isValidHostLabel($data['outpost_id'])) {
+            throw new InvalidArnException("The 7th component of an S3 Outposts"
+                . " bucket ARN is required, represents the outpost ID, and"
+                . " must be a valid host label.");
+        }
+
+        if ($data['bucket_label'] !== 'bucket') {
+            throw new InvalidArnException("The 8th component of an S3 Outposts"
+                . " bucket ARN must be 'bucket'");
+        }
+
+        if (empty($data['bucket_name'])) {
+            throw new InvalidArnException("The 9th component of an S3 Outposts"
+                . " bucket ARN represents the bucket name and must not be empty.");
+        }
+    }
+}

vendor/aws/aws-sdk-php/src/Artifact/ArtifactClient.php

@@ -0,0 +1,23 @@
+<?php
+namespace Aws\Artifact;
+
+use Aws\AwsClient;
+
+/**
+ * This client is used to interact with the **AWS Artifact** service.
+ * @method \Aws\Result getAccountSettings(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getAccountSettingsAsync(array $args = [])
+ * @method \Aws\Result getReport(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getReportAsync(array $args = [])
+ * @method \Aws\Result getReportMetadata(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getReportMetadataAsync(array $args = [])
+ * @method \Aws\Result getTermForReport(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getTermForReportAsync(array $args = [])
+ * @method \Aws\Result listCustomerAgreements(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCustomerAgreementsAsync(array $args = [])
+ * @method \Aws\Result listReports(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listReportsAsync(array $args = [])
+ * @method \Aws\Result putAccountSettings(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise putAccountSettingsAsync(array $args = [])
+ */
+class ArtifactClient extends AwsClient {}

vendor/aws/aws-sdk-php/src/Artifact/Exception/ArtifactException.php

@@ -0,0 +1,9 @@
+<?php
+namespace Aws\Artifact\Exception;
+
+use Aws\Exception\AwsException;
+
+/**
+ * Represents an error interacting with the **AWS Artifact** service.
+ */
+class ArtifactException extends AwsException {}

vendor/aws/aws-sdk-php/src/AwsClient.php

@@ -0,0 +1,800 @@
+<?php
+namespace Aws;
+
+use Aws\Api\ApiProvider;
+use Aws\Api\DocModel;
+use Aws\Api\Service;
+use Aws\Auth\AuthSelectionMiddleware;
+use Aws\Auth\AuthSchemeResolverInterface;
+use Aws\EndpointDiscovery\EndpointDiscoveryMiddleware;
+use Aws\EndpointV2\EndpointProviderV2;
+use Aws\EndpointV2\EndpointV2Middleware;
+use Aws\Exception\AwsException;
+use Aws\Signature\SignatureProvider;
+use GuzzleHttp\Psr7\Uri;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Default AWS client implementation
+ */
+class AwsClient implements AwsClientInterface
+{
+    use AwsClientTrait;
+
+    /** @var array */
+    private $aliases;
+
+    /** @var array */
+    private $config;
+
+    /** @var string */
+    private $region;
+
+    /** @var string */
+    private $signingRegionSet;
+
+    /** @var string */
+    private $endpoint;
+
+    /** @var Service */
+    private $api;
+
+    /** @var callable */
+    private $signatureProvider;
+
+    /** @var AuthSchemeResolverInterface */
+    private $authSchemeResolver;
+
+    /** @var callable */
+    private $credentialProvider;
+
+    /** @var callable */
+    private $tokenProvider;
+
+    /** @var HandlerList */
+    private $handlerList;
+
+    /** @var array*/
+    private $defaultRequestOptions;
+
+    /** @var array*/
+    private $clientContextParams = [];
+
+    /** @var array*/
+    protected $clientBuiltIns = [];
+
+    /** @var  EndpointProviderV2 | callable */
+    protected $endpointProvider;
+
+    /** @var callable */
+    protected $serializer;
+
+    /**
+     * Get an array of client constructor arguments used by the client.
+     *
+     * @return array
+     */
+    public static function getArguments()
+    {
+        return ClientResolver::getDefaultArguments();
+    }
+
+    /**
+     * The client constructor accepts the following options:
+     *
+     * - api_provider: (callable) An optional PHP callable that accepts a
+     *   type, service, and version argument, and returns an array of
+     *   corresponding configuration data. The type value can be one of api,
+     *   waiter, or paginator.
+     * - credentials:
+     *   (Aws\Credentials\CredentialsInterface|array|bool|callable) Specifies
+     *   the credentials used to sign requests. Provide an
+     *   Aws\Credentials\CredentialsInterface object, an associative array of
+     *   "key", "secret", and an optional "token" key, `false` to use null
+     *   credentials, or a callable credentials provider used to create
+     *   credentials or return null. See Aws\Credentials\CredentialProvider for
+     *   a list of built-in credentials providers. If no credentials are
+     *   provided, the SDK will attempt to load them from the environment.
+     * - token:
+     *   (Aws\Token\TokenInterface|array|bool|callable) Specifies
+     *   the token used to authorize requests. Provide an
+     *   Aws\Token\TokenInterface object, an associative array of
+     *   "token" and an optional "expires" key, `false` to use no
+     *   token, or a callable token provider used to create a
+     *   token or return null. See Aws\Token\TokenProvider for
+     *   a list of built-in token providers. If no token is
+     *   provided, the SDK will attempt to load one from the environment.
+     * - csm:
+     *   (Aws\ClientSideMonitoring\ConfigurationInterface|array|callable) Specifies
+     *   the credentials used to sign requests. Provide an
+     *   Aws\ClientSideMonitoring\ConfigurationInterface object, a callable
+     *   configuration provider used to create client-side monitoring configuration,
+     *   `false` to disable csm, or an associative array with the following keys:
+     *   enabled: (bool) Set to true to enable client-side monitoring, defaults
+     *   to false; host: (string) the host location to send monitoring events to,
+     *   defaults to 127.0.0.1; port: (int) The port used for the host connection,
+     *   defaults to 31000; client_id: (string) An identifier for this project
+     * - debug: (bool|array) Set to true to display debug information when
+     *   sending requests. Alternatively, you can provide an associative array
+     *   with the following keys: logfn: (callable) Function that is invoked
+     *   with log messages; stream_size: (int) When the size of a stream is
+     *   greater than this number, the stream data will not be logged (set to
+     *   "0" to not log any stream data); scrub_auth: (bool) Set to false to
+     *   disable the scrubbing of auth data from the logged messages; http:
+     *   (bool) Set to false to disable the "debug" feature of lower level HTTP
+     *   adapters (e.g., verbose curl output).
+     * - stats: (bool|array) Set to true to gather transfer statistics on
+     *   requests sent. Alternatively, you can provide an associative array with
+     *   the following keys: retries: (bool) Set to false to disable reporting
+     *   on retries attempted; http: (bool) Set to true to enable collecting
+     *   statistics from lower level HTTP adapters (e.g., values returned in
+     *   GuzzleHttp\TransferStats). HTTP handlers must support an
+     *   `http_stats_receiver` option for this to have an effect; timer: (bool)
+     *   Set to true to enable a command timer that reports the total wall clock
+     *   time spent on an operation in seconds.
+     * - disable_host_prefix_injection: (bool) Set to true to disable host prefix
+     *   injection logic for services that use it. This disables the entire
+     *   prefix injection, including the portions supplied by user-defined
+     *   parameters. Setting this flag will have no effect on services that do
+     *   not use host prefix injection.
+     * - endpoint: (string) The full URI of the webservice. This is only
+     *   required when connecting to a custom endpoint (e.g., a local version
+     *   of S3).
+     * - endpoint_discovery: (Aws\EndpointDiscovery\ConfigurationInterface,
+     *   Aws\CacheInterface, array, callable) Settings for endpoint discovery.
+     *   Provide an instance of Aws\EndpointDiscovery\ConfigurationInterface,
+     *   an instance Aws\CacheInterface, a callable that provides a promise for
+     *   a Configuration object, or an associative array with the following
+     *   keys: enabled: (bool) Set to true to enable endpoint discovery, false
+     *   to explicitly disable it, defaults to false; cache_limit: (int) The
+     *   maximum number of keys in the endpoints cache, defaults to 1000.
+     * - endpoint_provider: (callable) An optional PHP callable that
+     *   accepts a hash of options including a "service" and "region" key and
+     *   returns NULL or a hash of endpoint data, of which the "endpoint" key
+     *   is required. See Aws\Endpoint\EndpointProvider for a list of built-in
+     *   providers.
+     * - handler: (callable) A handler that accepts a command object,
+     *   request object and returns a promise that is fulfilled with an
+     *   Aws\ResultInterface object or rejected with an
+     *   Aws\Exception\AwsException. A handler does not accept a next handler
+     *   as it is terminal and expected to fulfill a command. If no handler is
+     *   provided, a default Guzzle handler will be utilized.
+     * - http: (array, default=array(0)) Set to an array of SDK request
+     *   options to apply to each request (e.g., proxy, verify, etc.).
+     * - http_handler: (callable) An HTTP handler is a function that
+     *   accepts a PSR-7 request object and returns a promise that is fulfilled
+     *   with a PSR-7 response object or rejected with an array of exception
+     *   data. NOTE: This option supersedes any provided "handler" option.
+     * - idempotency_auto_fill: (bool|callable) Set to false to disable SDK to
+     *   populate parameters that enabled 'idempotencyToken' trait with a random
+     *   UUID v4 value on your behalf. Using default value 'true' still allows
+     *   parameter value to be overwritten when provided. Note: auto-fill only
+     *   works when cryptographically secure random bytes generator functions
+     *   (random_bytes, openssl_random_pseudo_bytes or mcrypt_create_iv) can be
+     *   found. You may also provide a callable source of random bytes.
+     * - profile: (string) Allows you to specify which profile to use when
+     *   credentials are created from the AWS credentials file in your HOME
+     *   directory. This setting overrides the AWS_PROFILE environment
+     *   variable. Note: Specifying "profile" will cause the "credentials" key
+     *   to be ignored.
+     * - region: (string, required) Region to connect to. See
+     *   http://docs.aws.amazon.com/general/latest/gr/rande.html for a list of
+     *   available regions.
+     * - retries: (int, Aws\Retry\ConfigurationInterface, Aws\CacheInterface,
+     *   array, callable) Configures the retry mode and maximum number of
+     *   allowed retries for a client (pass 0 to disable retries). Provide an
+     *   integer for 'legacy' mode with the specified number of retries.
+     *   Otherwise provide an instance of Aws\Retry\ConfigurationInterface, an
+     *   instance of  Aws\CacheInterface, a callable function, or an array with
+     *   the following keys: mode: (string) Set to 'legacy', 'standard' (uses
+     *   retry quota management), or 'adapative' (an experimental mode that adds
+     *   client-side rate limiting to standard mode); max_attempts (int) The
+     *   maximum number of attempts for a given request.
+     * - scheme: (string, default=string(5) "https") URI scheme to use when
+     *   connecting connect. The SDK will utilize "https" endpoints (i.e.,
+     *   utilize SSL/TLS connections) by default. You can attempt to connect to
+     *   a service over an unencrypted "http" endpoint by setting ``scheme`` to
+     *   "http".
+     * - signature_provider: (callable) A callable that accepts a signature
+     *   version name (e.g., "v4"), a service name, and region, and
+     *   returns a SignatureInterface object or null. This provider is used to
+     *   create signers utilized by the client. See
+     *   Aws\Signature\SignatureProvider for a list of built-in providers
+     * - signature_version: (string) A string representing a custom
+     *   signature version to use with a service (e.g., v4). Note that
+     *   per/operation signature version MAY override this requested signature
+     *   version.
+     * - use_aws_shared_config_files: (bool, default=bool(true)) Set to false to
+     *   disable checking for shared config file in '~/.aws/config' and
+     *   '~/.aws/credentials'.  This will override the AWS_CONFIG_FILE
+     *   environment variable.
+     * - validate: (bool, default=bool(true)) Set to false to disable
+     *   client-side parameter validation.
+     * - version: (string, required) The version of the webservice to
+     *   utilize (e.g., 2006-03-01).
+     * - account_id_endpoint_mode: (string, default(preferred)) this option
+     *   decides whether credentials should resolve an accountId value,
+     *   which is going to be used as part of the endpoint resolution.
+     *   The valid values for this option are:
+     *   - preferred: when this value is set then, a warning is logged when
+     *     accountId is empty in the resolved identity.
+     *   - required: when this value is set then, an exception is thrown when
+     *     accountId is empty in the resolved identity.
+     *   - disabled: when this value is set then, the validation for if accountId
+     *     was resolved or not, is ignored.
+     * - ua_append: (string, array) To pass custom user agent parameters.
+     * - app_id: (string) an optional application specific identifier that can be set.
+     *   When set it will be appended to the User-Agent header of every request
+     *   in the form of App/{AppId}. This variable is sourced from environment
+     *   variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.
+     *   See https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html for
+     *   more information on environment variables and shared config settings.
+     *
+     * @param array $args Client configuration arguments.
+     *
+     * @throws \InvalidArgumentException if any required options are missing or
+     *                                   the service is not supported.
+     */
+    public function __construct(array $args)
+    {
+        list($service, $exceptionClass) = $this->parseClass();
+        if (!isset($args['service'])) {
+            $args['service'] = manifest($service)['endpoint'];
+        }
+        if (!isset($args['exception_class'])) {
+            $args['exception_class'] = $exceptionClass;
+        }
+        $this->handlerList = new HandlerList();
+        $resolver = new ClientResolver(static::getArguments());
+        $config = $resolver->resolve($args, $this->handlerList);
+        $this->api = $config['api'];
+        $this->signatureProvider = $config['signature_provider'];
+        $this->authSchemeResolver = $config['auth_scheme_resolver'];
+        $this->endpoint = new Uri($config['endpoint']);
+        $this->credentialProvider = $config['credentials'];
+        $this->tokenProvider = $config['token'];
+        $this->region = $config['region'] ?? null;
+        $this->signingRegionSet = $config['sigv4a_signing_region_set'] ?? null;
+        $this->config = $config['config'];
+        $this->setClientBuiltIns($args, $config);
+        $this->clientContextParams = $this->setClientContextParams($args);
+        $this->defaultRequestOptions = $config['http'];
+        $this->endpointProvider = $config['endpoint_provider'];
+        $this->serializer = $config['serializer'];
+        $this->addSignatureMiddleware($args);
+        $this->addInvocationId();
+        $this->addEndpointParameterMiddleware($args);
+        $this->addEndpointDiscoveryMiddleware($config, $args);
+        $this->addRequestCompressionMiddleware($config);
+        $this->loadAliases();
+        $this->addStreamRequestPayload();
+        $this->addRecursionDetection();
+        if ($this->isUseEndpointV2()) {
+            $this->addEndpointV2Middleware();
+        }
+        $this->addAuthSelectionMiddleware($config['config']);
+
+        if (!is_null($this->api->getMetadata('awsQueryCompatible'))) {
+            $this->addQueryCompatibleInputMiddleware($this->api);
+            $this->addQueryModeHeader();
+        }
+
+        if (isset($args['with_resolved'])) {
+            $args['with_resolved']($config);
+        }
+        $this->addUserAgentMiddleware($config);
+    }
+
+    public function getHandlerList()
+    {
+        return $this->handlerList;
+    }
+
+    public function getConfig($option = null)
+    {
+        return $option === null
+            ? $this->config
+            : $this->config[$option] ?? null;
+    }
+
+    public function getCredentials()
+    {
+        $fn = $this->credentialProvider;
+        return $fn();
+    }
+
+    public function getToken()
+    {
+        $fn = $this->tokenProvider;
+        return $fn();
+    }
+
+
+    public function getEndpoint()
+    {
+        return $this->endpoint;
+    }
+
+    public function getRegion()
+    {
+        return $this->region;
+    }
+
+    public function getApi()
+    {
+        return $this->api;
+    }
+
+    public function getCommand($name, array $args = [])
+    {
+        // Fail fast if the command cannot be found in the description.
+        if (!isset($this->getApi()['operations'][$name])) {
+            $name = ucfirst($name);
+            if (!isset($this->getApi()['operations'][$name])) {
+                throw new \InvalidArgumentException("Operation not found: $name");
+            }
+        }
+
+        if (!isset($args['@http'])) {
+            $args['@http'] = $this->defaultRequestOptions;
+        } else {
+            $args['@http'] += $this->defaultRequestOptions;
+        }
+
+        return new Command($name, $args, clone $this->getHandlerList());
+    }
+
+    public function getEndpointProvider()
+    {
+        return $this->endpointProvider;
+    }
+
+    /**
+     * Provides the set of service context parameter
+     * key-value pairs used for endpoint resolution.
+     *
+     * @return array
+     */
+    public function getClientContextParams()
+    {
+        return $this->clientContextParams;
+    }
+
+    /**
+     * Provides the set of built-in keys and values
+     * used for endpoint resolution
+     *
+     * @return array
+     */
+    public function getClientBuiltIns()
+    {
+        return $this->clientBuiltIns;
+    }
+
+    public function __sleep()
+    {
+        throw new \RuntimeException('Instances of ' . static::class
+            . ' cannot be serialized');
+    }
+
+    /**
+     * Get the signature_provider function of the client.
+     *
+     * @return callable
+     */
+    final public function getSignatureProvider()
+    {
+        return $this->signatureProvider;
+    }
+
+    /**
+     * Parse the class name and setup the custom exception class of the client
+     * and return the "service" name of the client and "exception_class".
+     *
+     * @return array
+     */
+    private function parseClass()
+    {
+        $klass = get_class($this);
+
+        if ($klass === __CLASS__) {
+            return ['', AwsException::class];
+        }
+
+        $service = substr($klass, strrpos($klass, '\\') + 1, -6);
+
+        return [
+            strtolower($service),
+            "Aws\\{$service}\\Exception\\{$service}Exception"
+        ];
+    }
+
+    private function addEndpointParameterMiddleware($args)
+    {
+        if (empty($args['disable_host_prefix_injection'])) {
+            $list = $this->getHandlerList();
+            $list->appendBuild(
+                EndpointParameterMiddleware::wrap(
+                    $this->api
+                ),
+                'endpoint_parameter'
+            );
+        }
+    }
+
+    private function addEndpointDiscoveryMiddleware($config, $args)
+    {
+        $list = $this->getHandlerList();
+
+        if (!isset($args['endpoint'])) {
+            $list->appendBuild(
+                EndpointDiscoveryMiddleware::wrap(
+                    $this,
+                    $args,
+                    $config['endpoint_discovery']
+                ),
+                'EndpointDiscoveryMiddleware'
+            );
+        }
+    }
+
+    private function addSignatureMiddleware(array $args)
+    {
+        $api = $this->getApi();
+        $provider = $this->signatureProvider;
+        $signatureVersion = $this->config['signature_version'];
+        $name = $this->config['signing_name'];
+        $region = $this->config['signing_region'];
+        $signingRegionSet = $this->signingRegionSet;
+
+        if (isset($args['signature_version'])
+         || isset($this->config['configured_signature_version'])
+        ) {
+            $configuredSignatureVersion = true;
+        } else {
+            $configuredSignatureVersion = false;
+        }
+
+        $resolver = static function (
+            CommandInterface $command
+        ) use (
+                $api,
+                $provider,
+                $name,
+                $region,
+                $signatureVersion,
+                $configuredSignatureVersion,
+                $signingRegionSet
+        ) {
+            if (!$configuredSignatureVersion) {
+                if (!empty($command['@context']['signing_region'])) {
+                    $region = $command['@context']['signing_region'];
+                }
+                if (!empty($command['@context']['signing_service'])) {
+                    $name = $command['@context']['signing_service'];
+                }
+                if (!empty($command['@context']['signature_version'])) {
+                    $signatureVersion = $command['@context']['signature_version'];
+                }
+
+                $authType = $api->getOperation($command->getName())['authtype'];
+                switch ($authType){
+                    case 'none':
+                        $signatureVersion = 'anonymous';
+                        break;
+                    case 'v4-unsigned-body':
+                        $signatureVersion = 'v4-unsigned-body';
+                        break;
+                    case 'bearer':
+                        $signatureVersion = 'bearer';
+                        break;
+                }
+            }
+
+            if ($signatureVersion === 'v4a') {
+                $commandSigningRegionSet = !empty($command['@context']['signing_region_set'])
+                    ? implode(', ', $command['@context']['signing_region_set'])
+                    : null;
+
+                $region = $signingRegionSet
+                    ?? $commandSigningRegionSet
+                    ?? $region;
+            }
+
+            // Capture signature metric
+            $command->getMetricsBuilder()->identifyMetricByValueAndAppend(
+                'signature',
+                $signatureVersion
+            );
+
+            return SignatureProvider::resolve($provider, $signatureVersion, $name, $region);
+        };
+        $this->handlerList->appendSign(
+            Middleware::signer($this->credentialProvider,
+                $resolver,
+                $this->tokenProvider,
+                $this->getConfig()
+            ),
+            'signer'
+        );
+    }
+
+    private function addRequestCompressionMiddleware($config)
+    {
+        if (empty($config['disable_request_compression'])) {
+            $list = $this->getHandlerList();
+            $list->appendBuild(
+                RequestCompressionMiddleware::wrap($config),
+                'request-compression'
+            );
+        }
+    }
+
+    private function addQueryCompatibleInputMiddleware(Service $api)
+    {
+            $list = $this->getHandlerList();
+            $list->appendValidate(
+                QueryCompatibleInputMiddleware::wrap($api),
+                'query-compatible-input'
+            );
+    }
+
+    private function addQueryModeHeader(): void
+    {
+        $list = $this->getHandlerList();
+        $list->appendBuild(
+            Middleware::mapRequest(function (RequestInterface $r) {
+                return $r->withHeader(
+                    'x-amzn-query-mode',
+                    "true"
+                );
+            }),
+            'x-amzn-query-mode-header'
+        );
+    }
+
+    private function addInvocationId()
+    {
+        // Add invocation id to each request
+        $this->handlerList->prependSign(Middleware::invocationId(), 'invocation-id');
+    }
+
+    private function loadAliases($file = null)
+    {
+        if (!isset($this->aliases)) {
+            if (is_null($file)) {
+                $file = __DIR__ . '/data/aliases.json';
+            }
+            $aliases = \Aws\load_compiled_json($file);
+            $serviceId = $this->api->getServiceId();
+            $version = $this->getApi()->getApiVersion();
+            if (!empty($aliases['operations'][$serviceId][$version])) {
+                $this->aliases = array_flip($aliases['operations'][$serviceId][$version]);
+            }
+        }
+    }
+
+    private function addStreamRequestPayload()
+    {
+        $streamRequestPayloadMiddleware = StreamRequestPayloadMiddleware::wrap(
+            $this->api
+        );
+
+        $this->handlerList->prependSign(
+            $streamRequestPayloadMiddleware,
+            'StreamRequestPayloadMiddleware'
+        );
+    }
+
+    private function addRecursionDetection()
+    {
+        // Add recursion detection header to requests
+        // originating in supported Lambda runtimes
+        $this->handlerList->appendBuild(
+            Middleware::recursionDetection(), 'recursion-detection'
+        );
+    }
+
+    private function addAuthSelectionMiddleware(array $args)
+    {
+        $list = $this->getHandlerList();
+
+        $list->prependBuild(
+            AuthSelectionMiddleware::wrap(
+                $this->authSchemeResolver,
+                $this->getApi(),
+                $args['auth_scheme_preference'] ?? null
+            ),
+            'auth-selection'
+        );
+    }
+
+    private function addEndpointV2Middleware()
+    {
+        $list = $this->getHandlerList();
+        $endpointArgs = $this->getEndpointProviderArgs();
+
+        $list->prependBuild(
+            EndpointV2Middleware::wrap(
+                $this->endpointProvider,
+                $this->getApi(),
+                $endpointArgs,
+                $this->credentialProvider
+            ),
+            'endpoint-resolution'
+        );
+    }
+
+    /**
+     * Appends the user agent middleware.
+     * This middleware MUST be appended after the
+     * signature middleware `addSignatureMiddleware`,
+     * so that metrics around signatures are properly
+     * captured.
+     *
+     * @param $args
+     * @return void
+     */
+    private function addUserAgentMiddleware($args)
+    {
+        $this->getHandlerList()->appendSign(
+            UserAgentMiddleware::wrap($args),
+            'user-agent'
+        );
+    }
+
+    /**
+     * Retrieves client context param definition from service model,
+     * creates mapping of client context param names with client-provided
+     * values.
+     *
+     * @return array
+     */
+    private function setClientContextParams($args)
+    {
+        $api = $this->getApi();
+        $resolvedParams = [];
+        if (!empty($paramDefinitions = $api->getClientContextParams())) {
+            foreach($paramDefinitions as $paramName => $paramValue) {
+                if (isset($args[$paramName])) {
+                   $resolvedParams[$paramName] = $args[$paramName];
+               }
+            }
+        }
+        return $resolvedParams;
+    }
+
+    /**
+     * Retrieves and sets default values used for endpoint resolution.
+     */
+    private function setClientBuiltIns($args, $resolvedConfig)
+    {
+        $builtIns = [];
+        $config = $resolvedConfig['config'];
+        $service = $args['service'];
+
+        $builtIns['SDK::Endpoint'] = null;
+        if (!empty($args['endpoint'])) {
+            $builtIns['SDK::Endpoint'] = $args['endpoint'];
+        } elseif (isset($config['configured_endpoint_url'])) {
+            $builtIns['SDK::Endpoint'] = (string) $this->getEndpoint();
+        }
+        $builtIns['AWS::Region'] = $this->getRegion();
+        $builtIns['AWS::UseFIPS'] = $config['use_fips_endpoint']->isUseFipsEndpoint();
+        $builtIns['AWS::UseDualStack'] = $config['use_dual_stack_endpoint']->isUseDualstackEndpoint();
+        if ($service === 's3' || $service === 's3control'){
+            $builtIns['AWS::S3::UseArnRegion'] = $config['use_arn_region']->isUseArnRegion();
+        }
+        if ($service === 's3') {
+            $builtIns['AWS::S3::UseArnRegion'] = $config['use_arn_region']->isUseArnRegion();
+            $builtIns['AWS::S3::Accelerate'] = $config['use_accelerate_endpoint'];
+            $builtIns['AWS::S3::ForcePathStyle'] = $config['use_path_style_endpoint'];
+            $builtIns['AWS::S3::DisableMultiRegionAccessPoints'] = $config['disable_multiregion_access_points'];
+        }
+        $builtIns['AWS::Auth::AccountIdEndpointMode'] = $resolvedConfig['account_id_endpoint_mode'];
+
+        $this->clientBuiltIns += $builtIns;
+    }
+
+    /**
+     * Retrieves arguments to be used in endpoint resolution.
+     *
+     * @return array
+     */
+    public function getEndpointProviderArgs()
+    {
+        return $this->normalizeEndpointProviderArgs();
+    }
+
+    /**
+     * Combines built-in and client context parameter values in
+     * order of specificity.  Client context parameter values supersede
+     * built-in values.
+     *
+     * @return array
+     */
+    private function normalizeEndpointProviderArgs()
+    {
+        $normalizedBuiltIns = [];
+
+        foreach($this->clientBuiltIns as $name => $value) {
+            $normalizedName = explode('::', $name);
+            $normalizedName = $normalizedName[count($normalizedName) - 1];
+            $normalizedBuiltIns[$normalizedName] = $value;
+        }
+
+        return array_merge($normalizedBuiltIns, $this->getClientContextParams());
+    }
+
+    protected function isUseEndpointV2()
+    {
+        return $this->endpointProvider instanceof EndpointProviderV2;
+    }
+
+    public static function emitDeprecationWarning() {
+        trigger_error(
+            "This method is deprecated. It will be removed in an upcoming release."
+            , E_USER_DEPRECATED
+        );
+
+        $phpVersion = PHP_VERSION_ID;
+        if ($phpVersion <  70205) {
+            $phpVersionString = phpversion();
+            @trigger_error(
+                "This installation of the SDK is using PHP version"
+                .  " {$phpVersionString}, which will be deprecated on August"
+                .  " 15th, 2023.  Please upgrade your PHP version to a minimum of"
+                .  " 7.2.5 before then to continue receiving updates to the AWS"
+                .  " SDK for PHP.  To disable this warning, set"
+                .  " suppress_php_deprecation_warning to true on the client constructor"
+                .  " or set the environment variable AWS_SUPPRESS_PHP_DEPRECATION_WARNING"
+                .  " to true.",
+                E_USER_DEPRECATED
+            );
+        }
+    }
+
+
+    /**
+     * Returns a service model and doc model with any necessary changes
+     * applied.
+     *
+     * @param array $api  Array of service data being documented.
+     * @param array $docs Array of doc model data.
+     *
+     * @return array Tuple containing a [Service, DocModel]
+     *
+     * @internal This should only used to document the service API.
+     * @codeCoverageIgnore
+     */
+    public static function applyDocFilters(array $api, array $docs)
+    {
+        $aliases = \Aws\load_compiled_json(__DIR__ . '/data/aliases.json');
+        $serviceId = $api['metadata']['serviceId'] ?? '';
+        $version = $api['metadata']['apiVersion'];
+
+        // Replace names for any operations with SDK aliases
+        if (!empty($aliases['operations'][$serviceId][$version])) {
+            foreach ($aliases['operations'][$serviceId][$version] as $op => $alias) {
+                $api['operations'][$alias] = $api['operations'][$op];
+                $docs['operations'][$alias] = $docs['operations'][$op];
+                unset($api['operations'][$op], $docs['operations'][$op]);
+            }
+        }
+        ksort($api['operations']);
+
+        return [
+            new Service($api, ApiProvider::defaultProvider()),
+            new DocModel($docs)
+        ];
+    }
+
+    /**
+     * @deprecated
+     * @return static
+     */
+    public static function factory(array $config = [])
+    {
+        return new static($config);
+    }
+}

vendor/aws/aws-sdk-php/src/AwsClientInterface.php

@@ -0,0 +1,169 @@
+<?php
+namespace Aws;
+
+use Psr\Http\Message\UriInterface;
+use GuzzleHttp\Promise\PromiseInterface;
+
+/**
+ * Represents an AWS client.
+ */
+interface AwsClientInterface
+{
+    /**
+     * Creates and executes a command for an operation by name.
+     *
+     * Suffixing an operation name with "Async" will return a
+     * promise that can be used to execute commands asynchronously.
+     *
+     * @param string $name      Name of the command to execute.
+     * @param array  $arguments Arguments to pass to the getCommand method.
+     *
+     * @return ResultInterface
+     * @throws \Exception
+     */
+    public function __call($name, array $arguments);
+
+    /**
+     * Create a command for an operation name.
+     *
+     * Special keys may be set on the command to control how it behaves,
+     * including:
+     *
+     * - @http: Associative array of transfer specific options to apply to the
+     *   request that is serialized for this command. Available keys include
+     *   "proxy", "verify", "timeout", "connect_timeout", "debug", "delay", and
+     *   "headers".
+     *
+     * @param string $name Name of the operation to use in the command
+     * @param array  $args Arguments to pass to the command
+     *
+     * @return CommandInterface
+     * @throws \InvalidArgumentException if no command can be found by name
+     */
+    public function getCommand($name, array $args = []);
+
+    /**
+     * Execute a single command.
+     *
+     * @param CommandInterface $command Command to execute
+     *
+     * @return ResultInterface
+     * @throws \Exception
+     */
+    public function execute(CommandInterface $command);
+
+    /**
+     * Execute a command asynchronously.
+     *
+     * @param CommandInterface $command Command to execute
+     *
+     * @return \GuzzleHttp\Promise\PromiseInterface
+     */
+    public function executeAsync(CommandInterface $command);
+
+    /**
+     * Returns a promise that is fulfilled with an
+     * {@see \Aws\Credentials\CredentialsInterface} object.
+     *
+     * If you need the credentials synchronously, then call the wait() method
+     * on the returned promise.
+     *
+     * @return PromiseInterface
+     */
+    public function getCredentials();
+
+    /**
+     * Get the region to which the client is configured to send requests.
+     *
+     * @return string
+     */
+    public function getRegion();
+
+    /**
+     * Gets the default endpoint, or base URL, used by the client.
+     *
+     * @return UriInterface
+     */
+    public function getEndpoint();
+
+    /**
+     * Get the service description associated with the client.
+     *
+     * @return \Aws\Api\Service
+     */
+    public function getApi();
+
+    /**
+     * Get a client configuration value.
+     *
+     * @param string|null $option The option to retrieve. Pass null to retrieve
+     *                            all options.
+     * @return mixed|null
+     */
+    public function getConfig($option = null);
+
+    /**
+     * Get the handler list used to transfer commands.
+     *
+     * This list can be modified to add middleware or to change the underlying
+     * handler used to send HTTP requests.
+     *
+     * @return HandlerList
+     */
+    public function getHandlerList();
+
+    /**
+     * Get a resource iterator for the specified operation.
+     *
+     * @param string $name Name of the iterator to retrieve.
+     * @param array  $args Command arguments to use with each command.
+     *
+     * @return \Iterator
+     * @throws \UnexpectedValueException if the iterator config is invalid.
+     */
+    public function getIterator($name, array $args = []);
+
+    /**
+     * Get a result paginator for the specified operation.
+     *
+     * @param string $name   Name of the operation used for iterator
+     * @param array  $args   Command args to be used with each command
+     *
+     * @return \Aws\ResultPaginator
+     * @throws \UnexpectedValueException if the iterator config is invalid.
+     */
+    public function getPaginator($name, array $args = []);
+
+    /**
+     * Wait until a resource is in a particular state.
+     *
+     * @param string|callable $name Name of the waiter that defines the wait
+     *                              configuration and conditions.
+     * @param array  $args          Args to be used with each command executed
+     *                              by the waiter. Waiter configuration options
+     *                              can be provided in an associative array in
+     *                              the @waiter key.
+     * @return void
+     * @throws \UnexpectedValueException if the waiter is invalid.
+     */
+    public function waitUntil($name, array $args = []);
+
+    /**
+     * Get a waiter that waits until a resource is in a particular state.
+     *
+     * Retrieving a waiter can be useful when you wish to wait asynchronously:
+     *
+     *     $waiter = $client->getWaiter('foo', ['bar' => 'baz']);
+     *     $waiter->promise()->then(function () { echo 'Done!'; });
+     *
+     * @param string|callable $name Name of the waiter that defines the wait
+     *                              configuration and conditions.
+     * @param array  $args          Args to be used with each command executed
+     *                              by the waiter. Waiter configuration options
+     *                              can be provided in an associative array in
+     *                              the @waiter key.
+     * @return \Aws\Waiter
+     * @throws \UnexpectedValueException if the waiter is invalid.
+     */
+    public function getWaiter($name, array $args = []);
+}

vendor/aws/aws-sdk-php/src/AwsClientTrait.php

@@ -0,0 +1,101 @@
+<?php
+namespace Aws;
+
+use Aws\Api\Service;
+
+/**
+ * A trait providing generic functionality for interacting with Amazon Web
+ * Services. This is meant to be used in classes implementing
+ * \Aws\AwsClientInterface
+ */
+trait AwsClientTrait
+{
+    public function getPaginator($name, array $args = [])
+    {
+        $config = $this->getApi()->getPaginatorConfig($name);
+
+        return new ResultPaginator($this, $name, $args, $config);
+    }
+
+    public function getIterator($name, array $args = [])
+    {
+        $config = $this->getApi()->getPaginatorConfig($name);
+        if (!$config['result_key']) {
+            throw new \UnexpectedValueException(sprintf(
+                'There are no resources to iterate for the %s operation of %s',
+                $name, $this->getApi()['serviceFullName']
+            ));
+        }
+
+        $key = is_array($config['result_key'])
+            ? $config['result_key'][0]
+            : $config['result_key'];
+
+        if ($config['output_token'] && $config['input_token']) {
+            return $this->getPaginator($name, $args)->search($key);
+        }
+
+        $result = $this->execute($this->getCommand($name, $args))->search($key);
+
+        return new \ArrayIterator((array) $result);
+    }
+
+    public function waitUntil($name, array $args = [])
+    {
+        return $this->getWaiter($name, $args)->promise()->wait();
+    }
+
+    public function getWaiter($name, array $args = [])
+    {
+        $config = isset($args['@waiter']) ? $args['@waiter'] : [];
+        $config += $this->getApi()->getWaiterConfig($name);
+
+        return new Waiter($this, $name, $args, $config);
+    }
+
+    public function execute(CommandInterface $command)
+    {
+        return $this->executeAsync($command)->wait();
+    }
+
+    public function executeAsync(CommandInterface $command)
+    {
+        $handler = $command->getHandlerList()->resolve();
+        return $handler($command);
+    }
+
+    public function __call($name, array $args)
+    {
+        if (substr($name, -5) === 'Async') {
+            $name = substr($name, 0, -5);
+            $isAsync = true;
+        }
+
+        if (!empty($this->aliases[ucfirst($name)])) {
+            $name = $this->aliases[ucfirst($name)];
+        }
+
+        $params = isset($args[0]) ? $args[0] : [];
+
+        if (!empty($isAsync)) {
+            return $this->executeAsync(
+                $this->getCommand($name, $params)
+            );
+        }
+
+        return $this->execute($this->getCommand($name, $params));
+    }
+
+    /**
+     * @param string $name
+     * @param array $args
+     *
+     * @return CommandInterface
+     */
+    abstract public function getCommand($name, array $args = []);
+
+    /**
+     * @return Service
+     */
+    abstract public function getApi();
+}

vendor/aws/aws-sdk-php/src/CacheInterface.php

@@ -0,0 +1,34 @@
+<?php
+namespace Aws;
+
+/**
+ * Represents a simple cache interface.
+ */
+interface CacheInterface
+{
+    /**
+     * Get a cache item by key.
+     *
+     * @param string $key Key to retrieve.
+     *
+     * @return mixed|null Returns the value or null if not found.
+     */
+    public function get($key);
+
+    /**
+     * Set a cache key value.
+     *
+     * @param string $key   Key to set
+     * @param mixed  $value Value to set.
+     * @param int    $ttl   Number of seconds the item is allowed to live. Set
+     *                      to 0 to allow an unlimited lifetime.
+     */
+    public function set($key, $value, $ttl = 0);
+
+    /**
+     * Remove a cache key.
+     *
+     * @param string $key Key to remove.
+     */
+    public function remove($key);
+}

vendor/aws/aws-sdk-php/src/CleanRooms/CleanRoomsClient.php

@@ -0,0 +1,183 @@
+<?php
+namespace Aws\CleanRooms;
+
+use Aws\AwsClient;
+
+/**
+ * This client is used to interact with the **AWS Clean Rooms Service** service.
+ * @method \Aws\Result batchGetCollaborationAnalysisTemplate(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise batchGetCollaborationAnalysisTemplateAsync(array $args = [])
+ * @method \Aws\Result batchGetSchema(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise batchGetSchemaAsync(array $args = [])
+ * @method \Aws\Result batchGetSchemaAnalysisRule(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise batchGetSchemaAnalysisRuleAsync(array $args = [])
+ * @method \Aws\Result createAnalysisTemplate(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createAnalysisTemplateAsync(array $args = [])
+ * @method \Aws\Result createCollaboration(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createCollaborationAsync(array $args = [])
+ * @method \Aws\Result createCollaborationChangeRequest(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createCollaborationChangeRequestAsync(array $args = [])
+ * @method \Aws\Result createConfiguredAudienceModelAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createConfiguredAudienceModelAssociationAsync(array $args = [])
+ * @method \Aws\Result createConfiguredTable(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createConfiguredTableAsync(array $args = [])
+ * @method \Aws\Result createConfiguredTableAnalysisRule(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createConfiguredTableAnalysisRuleAsync(array $args = [])
+ * @method \Aws\Result createConfiguredTableAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createConfiguredTableAssociationAsync(array $args = [])
+ * @method \Aws\Result createConfiguredTableAssociationAnalysisRule(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createConfiguredTableAssociationAnalysisRuleAsync(array $args = [])
+ * @method \Aws\Result createIdMappingTable(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createIdMappingTableAsync(array $args = [])
+ * @method \Aws\Result createIdNamespaceAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createIdNamespaceAssociationAsync(array $args = [])
+ * @method \Aws\Result createMembership(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createMembershipAsync(array $args = [])
+ * @method \Aws\Result createPrivacyBudgetTemplate(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createPrivacyBudgetTemplateAsync(array $args = [])
+ * @method \Aws\Result deleteAnalysisTemplate(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteAnalysisTemplateAsync(array $args = [])
+ * @method \Aws\Result deleteCollaboration(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteCollaborationAsync(array $args = [])
+ * @method \Aws\Result deleteConfiguredAudienceModelAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteConfiguredAudienceModelAssociationAsync(array $args = [])
+ * @method \Aws\Result deleteConfiguredTable(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteConfiguredTableAsync(array $args = [])
+ * @method \Aws\Result deleteConfiguredTableAnalysisRule(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteConfiguredTableAnalysisRuleAsync(array $args = [])
+ * @method \Aws\Result deleteConfiguredTableAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteConfiguredTableAssociationAsync(array $args = [])
+ * @method \Aws\Result deleteConfiguredTableAssociationAnalysisRule(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteConfiguredTableAssociationAnalysisRuleAsync(array $args = [])
+ * @method \Aws\Result deleteIdMappingTable(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteIdMappingTableAsync(array $args = [])
+ * @method \Aws\Result deleteIdNamespaceAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteIdNamespaceAssociationAsync(array $args = [])
+ * @method \Aws\Result deleteMember(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteMemberAsync(array $args = [])
+ * @method \Aws\Result deleteMembership(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteMembershipAsync(array $args = [])
+ * @method \Aws\Result deletePrivacyBudgetTemplate(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deletePrivacyBudgetTemplateAsync(array $args = [])
+ * @method \Aws\Result getAnalysisTemplate(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getAnalysisTemplateAsync(array $args = [])
+ * @method \Aws\Result getCollaboration(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getCollaborationAsync(array $args = [])
+ * @method \Aws\Result getCollaborationAnalysisTemplate(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getCollaborationAnalysisTemplateAsync(array $args = [])
+ * @method \Aws\Result getCollaborationChangeRequest(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getCollaborationChangeRequestAsync(array $args = [])
+ * @method \Aws\Result getCollaborationConfiguredAudienceModelAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getCollaborationConfiguredAudienceModelAssociationAsync(array $args = [])
+ * @method \Aws\Result getCollaborationIdNamespaceAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getCollaborationIdNamespaceAssociationAsync(array $args = [])
+ * @method \Aws\Result getCollaborationPrivacyBudgetTemplate(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getCollaborationPrivacyBudgetTemplateAsync(array $args = [])
+ * @method \Aws\Result getConfiguredAudienceModelAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getConfiguredAudienceModelAssociationAsync(array $args = [])
+ * @method \Aws\Result getConfiguredTable(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getConfiguredTableAsync(array $args = [])
+ * @method \Aws\Result getConfiguredTableAnalysisRule(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getConfiguredTableAnalysisRuleAsync(array $args = [])
+ * @method \Aws\Result getConfiguredTableAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getConfiguredTableAssociationAsync(array $args = [])
+ * @method \Aws\Result getConfiguredTableAssociationAnalysisRule(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getConfiguredTableAssociationAnalysisRuleAsync(array $args = [])
+ * @method \Aws\Result getIdMappingTable(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getIdMappingTableAsync(array $args = [])
+ * @method \Aws\Result getIdNamespaceAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getIdNamespaceAssociationAsync(array $args = [])
+ * @method \Aws\Result getMembership(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getMembershipAsync(array $args = [])
+ * @method \Aws\Result getPrivacyBudgetTemplate(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getPrivacyBudgetTemplateAsync(array $args = [])
+ * @method \Aws\Result getProtectedJob(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getProtectedJobAsync(array $args = [])
+ * @method \Aws\Result getProtectedQuery(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getProtectedQueryAsync(array $args = [])
+ * @method \Aws\Result getSchema(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getSchemaAsync(array $args = [])
+ * @method \Aws\Result getSchemaAnalysisRule(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getSchemaAnalysisRuleAsync(array $args = [])
+ * @method \Aws\Result listAnalysisTemplates(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listAnalysisTemplatesAsync(array $args = [])
+ * @method \Aws\Result listCollaborationAnalysisTemplates(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCollaborationAnalysisTemplatesAsync(array $args = [])
+ * @method \Aws\Result listCollaborationChangeRequests(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCollaborationChangeRequestsAsync(array $args = [])
+ * @method \Aws\Result listCollaborationConfiguredAudienceModelAssociations(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCollaborationConfiguredAudienceModelAssociationsAsync(array $args = [])
+ * @method \Aws\Result listCollaborationIdNamespaceAssociations(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCollaborationIdNamespaceAssociationsAsync(array $args = [])
+ * @method \Aws\Result listCollaborationPrivacyBudgetTemplates(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCollaborationPrivacyBudgetTemplatesAsync(array $args = [])
+ * @method \Aws\Result listCollaborationPrivacyBudgets(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCollaborationPrivacyBudgetsAsync(array $args = [])
+ * @method \Aws\Result listCollaborations(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCollaborationsAsync(array $args = [])
+ * @method \Aws\Result listConfiguredAudienceModelAssociations(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listConfiguredAudienceModelAssociationsAsync(array $args = [])
+ * @method \Aws\Result listConfiguredTableAssociations(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listConfiguredTableAssociationsAsync(array $args = [])
+ * @method \Aws\Result listConfiguredTables(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listConfiguredTablesAsync(array $args = [])
+ * @method \Aws\Result listIdMappingTables(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listIdMappingTablesAsync(array $args = [])
+ * @method \Aws\Result listIdNamespaceAssociations(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listIdNamespaceAssociationsAsync(array $args = [])
+ * @method \Aws\Result listMembers(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listMembersAsync(array $args = [])
+ * @method \Aws\Result listMemberships(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listMembershipsAsync(array $args = [])
+ * @method \Aws\Result listPrivacyBudgetTemplates(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listPrivacyBudgetTemplatesAsync(array $args = [])
+ * @method \Aws\Result listPrivacyBudgets(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listPrivacyBudgetsAsync(array $args = [])
+ * @method \Aws\Result listProtectedJobs(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listProtectedJobsAsync(array $args = [])
+ * @method \Aws\Result listProtectedQueries(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listProtectedQueriesAsync(array $args = [])
+ * @method \Aws\Result listSchemas(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listSchemasAsync(array $args = [])
+ * @method \Aws\Result listTagsForResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listTagsForResourceAsync(array $args = [])
+ * @method \Aws\Result populateIdMappingTable(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise populateIdMappingTableAsync(array $args = [])
+ * @method \Aws\Result previewPrivacyImpact(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise previewPrivacyImpactAsync(array $args = [])
+ * @method \Aws\Result startProtectedJob(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise startProtectedJobAsync(array $args = [])
+ * @method \Aws\Result startProtectedQuery(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise startProtectedQueryAsync(array $args = [])
+ * @method \Aws\Result tagResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise tagResourceAsync(array $args = [])
+ * @method \Aws\Result untagResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise untagResourceAsync(array $args = [])
+ * @method \Aws\Result updateAnalysisTemplate(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateAnalysisTemplateAsync(array $args = [])
+ * @method \Aws\Result updateCollaboration(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateCollaborationAsync(array $args = [])
+ * @method \Aws\Result updateConfiguredAudienceModelAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateConfiguredAudienceModelAssociationAsync(array $args = [])
+ * @method \Aws\Result updateConfiguredTable(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateConfiguredTableAsync(array $args = [])
+ * @method \Aws\Result updateConfiguredTableAnalysisRule(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateConfiguredTableAnalysisRuleAsync(array $args = [])
+ * @method \Aws\Result updateConfiguredTableAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateConfiguredTableAssociationAsync(array $args = [])
+ * @method \Aws\Result updateConfiguredTableAssociationAnalysisRule(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateConfiguredTableAssociationAnalysisRuleAsync(array $args = [])
+ * @method \Aws\Result updateIdMappingTable(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateIdMappingTableAsync(array $args = [])
+ * @method \Aws\Result updateIdNamespaceAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateIdNamespaceAssociationAsync(array $args = [])
+ * @method \Aws\Result updateMembership(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateMembershipAsync(array $args = [])
+ * @method \Aws\Result updatePrivacyBudgetTemplate(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updatePrivacyBudgetTemplateAsync(array $args = [])
+ * @method \Aws\Result updateProtectedJob(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateProtectedJobAsync(array $args = [])
+ * @method \Aws\Result updateProtectedQuery(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateProtectedQueryAsync(array $args = [])
+ */
+class CleanRoomsClient extends AwsClient {}

vendor/aws/aws-sdk-php/src/CleanRooms/Exception/CleanRoomsException.php

@@ -0,0 +1,9 @@
+<?php
+namespace Aws\CleanRooms\Exception;
+
+use Aws\Exception\AwsException;
+
+/**
+ * Represents an error interacting with the **AWS Clean Rooms Service** service.
+ */
+class CleanRoomsException extends AwsException {}

vendor/aws/aws-sdk-php/src/CleanRoomsML/CleanRoomsMLClient.php

@@ -0,0 +1,127 @@
+<?php
+namespace Aws\CleanRoomsML;
+
+use Aws\AwsClient;
+
+/**
+ * This client is used to interact with the **cleanrooms-ml** service.
+ * @method \Aws\Result cancelTrainedModel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise cancelTrainedModelAsync(array $args = [])
+ * @method \Aws\Result cancelTrainedModelInferenceJob(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise cancelTrainedModelInferenceJobAsync(array $args = [])
+ * @method \Aws\Result createAudienceModel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createAudienceModelAsync(array $args = [])
+ * @method \Aws\Result createConfiguredAudienceModel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createConfiguredAudienceModelAsync(array $args = [])
+ * @method \Aws\Result createConfiguredModelAlgorithm(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createConfiguredModelAlgorithmAsync(array $args = [])
+ * @method \Aws\Result createConfiguredModelAlgorithmAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createConfiguredModelAlgorithmAssociationAsync(array $args = [])
+ * @method \Aws\Result createMLInputChannel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createMLInputChannelAsync(array $args = [])
+ * @method \Aws\Result createTrainedModel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createTrainedModelAsync(array $args = [])
+ * @method \Aws\Result createTrainingDataset(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise createTrainingDatasetAsync(array $args = [])
+ * @method \Aws\Result deleteAudienceGenerationJob(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteAudienceGenerationJobAsync(array $args = [])
+ * @method \Aws\Result deleteAudienceModel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteAudienceModelAsync(array $args = [])
+ * @method \Aws\Result deleteConfiguredAudienceModel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteConfiguredAudienceModelAsync(array $args = [])
+ * @method \Aws\Result deleteConfiguredAudienceModelPolicy(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteConfiguredAudienceModelPolicyAsync(array $args = [])
+ * @method \Aws\Result deleteConfiguredModelAlgorithm(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteConfiguredModelAlgorithmAsync(array $args = [])
+ * @method \Aws\Result deleteConfiguredModelAlgorithmAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteConfiguredModelAlgorithmAssociationAsync(array $args = [])
+ * @method \Aws\Result deleteMLConfiguration(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteMLConfigurationAsync(array $args = [])
+ * @method \Aws\Result deleteMLInputChannelData(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteMLInputChannelDataAsync(array $args = [])
+ * @method \Aws\Result deleteTrainedModelOutput(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteTrainedModelOutputAsync(array $args = [])
+ * @method \Aws\Result deleteTrainingDataset(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise deleteTrainingDatasetAsync(array $args = [])
+ * @method \Aws\Result getAudienceGenerationJob(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getAudienceGenerationJobAsync(array $args = [])
+ * @method \Aws\Result getAudienceModel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getAudienceModelAsync(array $args = [])
+ * @method \Aws\Result getCollaborationConfiguredModelAlgorithmAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getCollaborationConfiguredModelAlgorithmAssociationAsync(array $args = [])
+ * @method \Aws\Result getCollaborationMLInputChannel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getCollaborationMLInputChannelAsync(array $args = [])
+ * @method \Aws\Result getCollaborationTrainedModel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getCollaborationTrainedModelAsync(array $args = [])
+ * @method \Aws\Result getConfiguredAudienceModel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getConfiguredAudienceModelAsync(array $args = [])
+ * @method \Aws\Result getConfiguredAudienceModelPolicy(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getConfiguredAudienceModelPolicyAsync(array $args = [])
+ * @method \Aws\Result getConfiguredModelAlgorithm(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getConfiguredModelAlgorithmAsync(array $args = [])
+ * @method \Aws\Result getConfiguredModelAlgorithmAssociation(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getConfiguredModelAlgorithmAssociationAsync(array $args = [])
+ * @method \Aws\Result getMLConfiguration(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getMLConfigurationAsync(array $args = [])
+ * @method \Aws\Result getMLInputChannel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getMLInputChannelAsync(array $args = [])
+ * @method \Aws\Result getTrainedModel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getTrainedModelAsync(array $args = [])
+ * @method \Aws\Result getTrainedModelInferenceJob(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getTrainedModelInferenceJobAsync(array $args = [])
+ * @method \Aws\Result getTrainingDataset(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise getTrainingDatasetAsync(array $args = [])
+ * @method \Aws\Result listAudienceExportJobs(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listAudienceExportJobsAsync(array $args = [])
+ * @method \Aws\Result listAudienceGenerationJobs(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listAudienceGenerationJobsAsync(array $args = [])
+ * @method \Aws\Result listAudienceModels(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listAudienceModelsAsync(array $args = [])
+ * @method \Aws\Result listCollaborationConfiguredModelAlgorithmAssociations(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCollaborationConfiguredModelAlgorithmAssociationsAsync(array $args = [])
+ * @method \Aws\Result listCollaborationMLInputChannels(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCollaborationMLInputChannelsAsync(array $args = [])
+ * @method \Aws\Result listCollaborationTrainedModelExportJobs(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCollaborationTrainedModelExportJobsAsync(array $args = [])
+ * @method \Aws\Result listCollaborationTrainedModelInferenceJobs(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCollaborationTrainedModelInferenceJobsAsync(array $args = [])
+ * @method \Aws\Result listCollaborationTrainedModels(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listCollaborationTrainedModelsAsync(array $args = [])
+ * @method \Aws\Result listConfiguredAudienceModels(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listConfiguredAudienceModelsAsync(array $args = [])
+ * @method \Aws\Result listConfiguredModelAlgorithmAssociations(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listConfiguredModelAlgorithmAssociationsAsync(array $args = [])
+ * @method \Aws\Result listConfiguredModelAlgorithms(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listConfiguredModelAlgorithmsAsync(array $args = [])
+ * @method \Aws\Result listMLInputChannels(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listMLInputChannelsAsync(array $args = [])
+ * @method \Aws\Result listTagsForResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listTagsForResourceAsync(array $args = [])
+ * @method \Aws\Result listTrainedModelInferenceJobs(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listTrainedModelInferenceJobsAsync(array $args = [])
+ * @method \Aws\Result listTrainedModelVersions(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listTrainedModelVersionsAsync(array $args = [])
+ * @method \Aws\Result listTrainedModels(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listTrainedModelsAsync(array $args = [])
+ * @method \Aws\Result listTrainingDatasets(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise listTrainingDatasetsAsync(array $args = [])
+ * @method \Aws\Result putConfiguredAudienceModelPolicy(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise putConfiguredAudienceModelPolicyAsync(array $args = [])
+ * @method \Aws\Result putMLConfiguration(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise putMLConfigurationAsync(array $args = [])
+ * @method \Aws\Result startAudienceExportJob(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise startAudienceExportJobAsync(array $args = [])
+ * @method \Aws\Result startAudienceGenerationJob(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise startAudienceGenerationJobAsync(array $args = [])
+ * @method \Aws\Result startTrainedModelExportJob(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise startTrainedModelExportJobAsync(array $args = [])
+ * @method \Aws\Result startTrainedModelInferenceJob(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise startTrainedModelInferenceJobAsync(array $args = [])
+ * @method \Aws\Result tagResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise tagResourceAsync(array $args = [])
+ * @method \Aws\Result untagResource(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise untagResourceAsync(array $args = [])
+ * @method \Aws\Result updateConfiguredAudienceModel(array $args = [])
+ * @method \GuzzleHttp\Promise\Promise updateConfiguredAudienceModelAsync(array $args = [])
+ */
+class CleanRoomsMLClient extends AwsClient {}

vendor/aws/aws-sdk-php/src/CleanRoomsML/Exception/CleanRoomsMLException.php

@@ -0,0 +1,9 @@
+<?php
+namespace Aws\CleanRoomsML\Exception;
+
+use Aws\Exception\AwsException;
+
+/**
+ * Represents an error interacting with the **cleanrooms-ml** service.
+ */
+class CleanRoomsMLException extends AwsException {}

vendor/aws/aws-sdk-php/src/ClientSideMonitoring/AbstractMonitoringMiddleware.php

@@ -0,0 +1,309 @@
+<?php
+
+namespace Aws\ClientSideMonitoring;
+
+use Aws\CommandInterface;
+use Aws\Exception\AwsException;
+use Aws\MonitoringEventsInterface;
+use Aws\ResponseContainerInterface;
+use Aws\ResultInterface;
+use GuzzleHttp\Promise;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * @internal
+ */
+abstract class AbstractMonitoringMiddleware
+    implements MonitoringMiddlewareInterface
+{
+    private static $socket;
+
+    private $nextHandler;
+    private $options;
+    protected $credentialProvider;
+    protected $region;
+    protected $service;
+
+    protected static function getAwsExceptionHeader(AwsException $e, $headerName)
+    {
+        $response = $e->getResponse();
+        if ($response !== null) {
+            $header = $response->getHeader($headerName);
+            if (!empty($header[0])) {
+                return $header[0];
+            }
+        }
+        return null;
+    }
+
+    protected static function getResultHeader(ResultInterface $result, $headerName)
+    {
+        if (isset($result['@metadata']['headers'][$headerName])) {
+            return $result['@metadata']['headers'][$headerName];
+        }
+        return null;
+    }
+
+    protected static function getExceptionHeader(\Exception $e, $headerName)
+    {
+        if ($e instanceof ResponseContainerInterface) {
+            $response = $e->getResponse();
+            if ($response instanceof ResponseInterface) {
+                $header = $response->getHeader($headerName);
+                if (!empty($header[0])) {
+                    return $header[0];
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Constructor stores the passed in handler and options.
+     *
+     * @param callable $handler
+     * @param callable $credentialProvider
+     * @param $options
+     * @param $region
+     * @param $service
+     */
+    public function __construct(
+        callable $handler,
+        callable $credentialProvider,
+        $options,
+        $region,
+        $service
+    ) {
+        $this->nextHandler = $handler;
+        $this->credentialProvider = $credentialProvider;
+        $this->options = $options;
+        $this->region = $region;
+        $this->service = $service;
+    }
+
+    /**
+     * Standard invoke pattern for middleware execution to be implemented by
+     * child classes.
+     *
+     * @param  CommandInterface $cmd
+     * @param  RequestInterface $request
+     * @return Promise\PromiseInterface
+     */
+    public function __invoke(CommandInterface $cmd, RequestInterface $request)
+    {
+        $handler = $this->nextHandler;
+        $eventData = null;
+        $enabled = $this->isEnabled();
+
+        if ($enabled) {
+            $cmd['@http']['collect_stats'] = true;
+            $eventData = $this->populateRequestEventData(
+                $cmd,
+                $request,
+                $this->getNewEvent($cmd, $request)
+            );
+        }
+
+        $g = function ($value) use ($eventData, $enabled) {
+            if ($enabled) {
+                $eventData = $this->populateResultEventData(
+                    $value,
+                    $eventData
+                );
+                $this->sendEventData($eventData);
+
+                if ($value instanceof MonitoringEventsInterface) {
+                    $value->appendMonitoringEvent($eventData);
+                }
+            }
+            if ($value instanceof \Exception || $value instanceof \Throwable) {
+                return Promise\Create::rejectionFor($value);
+            }
+            return $value;
+        };
+
+        return Promise\Create::promiseFor($handler($cmd, $request))->then($g, $g);
+    }
+
+    private function getClientId()
+    {
+        return $this->unwrappedOptions()->getClientId();
+    }
+
+    private function getNewEvent(
+        CommandInterface $cmd,
+        RequestInterface $request
+    ) {
+        $event = [
+            'Api' => $cmd->getName(),
+            'ClientId' => $this->getClientId(),
+            'Region' => $this->getRegion(),
+            'Service' => $this->getService(),
+            'Timestamp' => (int) floor(microtime(true) * 1000),
+            'UserAgent' => substr(
+                $request->getHeaderLine('User-Agent') . ' ' . \Aws\default_user_agent(),
+                0,
+                256
+            ),
+            'Version' => 1
+        ];
+        return $event;
+    }
+
+    private function getHost()
+    {
+        return $this->unwrappedOptions()->getHost();
+    }
+
+    private function getPort()
+    {
+        return $this->unwrappedOptions()->getPort();
+    }
+
+    private function getRegion()
+    {
+        return $this->region;
+    }
+
+    private function getService()
+    {
+        return $this->service;
+    }
+
+    /**
+     * Returns enabled flag from options, unwrapping options if necessary.
+     *
+     * @return bool
+     */
+    private function isEnabled()
+    {
+        return $this->unwrappedOptions()->isEnabled();
+    }
+
+    /**
+     * Returns $eventData array with information from the request and command.
+     *
+     * @param CommandInterface $cmd
+     * @param RequestInterface $request
+     * @param array $event
+     * @return array
+     */
+    protected function populateRequestEventData(
+        CommandInterface $cmd,
+        RequestInterface $request,
+        array $event
+    ) {
+        $dataFormat = static::getRequestData($request);
+        foreach ($dataFormat as $eventKey => $value) {
+            if ($value !== null) {
+                $event[$eventKey] = $value;
+            }
+        }
+        return $event;
+    }
+
+    /**
+     * Returns $eventData array with information from the response, including
+     * the calculation for attempt latency.
+     *
+     * @param ResultInterface|\Exception $result
+     * @param array $event
+     * @return array
+     */
+    protected function populateResultEventData(
+        $result,
+        array $event
+    ) {
+        $dataFormat = static::getResponseData($result);
+        foreach ($dataFormat as $eventKey => $value) {
+            if ($value !== null) {
+                $event[$eventKey] = $value;
+            }
+        }
+        return $event;
+    }
+
+
+    /**
+     * Checks if the socket is created. If PHP version is greater or equals to 8 then,
+     * it will check if the var is instance of \Socket otherwise it will check if is
+     * a resource.
+     *
+     * @return bool Returns true if the socket is created, false otherwise.
+     */
+    private function isSocketCreated(): bool
+    {
+        // Before version 8, sockets are resources
+        // After version 8, sockets are instances of Socket
+        if (PHP_MAJOR_VERSION >= 8) {
+            $socketClass = '\Socket';
+            return self::$socket instanceof $socketClass;
+        } else {
+            return is_resource(self::$socket);
+        }
+    }
+
+    /**
+     * Creates a UDP socket resource and stores it with the class, or retrieves
+     * it if already instantiated and connected. Handles error-checking and
+     * re-connecting if necessary. If $forceNewConnection is set to true, a new
+     * socket will be created.
+     *
+     * @param bool $forceNewConnection
+     * @return Resource
+     */
+    private function prepareSocket($forceNewConnection = false)
+    {
+        if (!$this->isSocketCreated()
+            || $forceNewConnection
+            || socket_last_error(self::$socket)
+        ) {
+            self::$socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
+            socket_clear_error(self::$socket);
+            socket_connect(self::$socket, $this->getHost(), $this->getPort());
+        }
+
+        return self::$socket;
+    }
+
+    /**
+     * Sends formatted monitoring event data via the UDP socket connection to
+     * the CSM agent endpoint.
+     *
+     * @param array $eventData
+     * @return int
+     */
+    private function sendEventData(array $eventData)
+    {
+        $socket = $this->prepareSocket();
+        $datagram = json_encode($eventData);
+        $result = socket_write($socket, $datagram, strlen($datagram));
+        if ($result === false) {
+            $this->prepareSocket(true);
+        }
+        return $result;
+    }
+
+    /**
+     * Unwraps options, if needed, and returns them.
+     *
+     * @return ConfigurationInterface
+     */
+    private function unwrappedOptions()
+    {
+        if (!($this->options instanceof ConfigurationInterface)) {
+            try {
+                $this->options = ConfigurationProvider::unwrap($this->options);
+            } catch (\Exception $e) {
+                // Errors unwrapping CSM config defaults to disabling it
+                $this->options = new Configuration(
+                    false,
+                    ConfigurationProvider::DEFAULT_HOST,
+                    ConfigurationProvider::DEFAULT_PORT
+                );
+            }
+        }
+        return $this->options;
+    }
+}

vendor/aws/aws-sdk-php/src/ClientSideMonitoring/ApiCallAttemptMonitoringMiddleware.php

@@ -0,0 +1,262 @@
+<?php
+
+namespace Aws\ClientSideMonitoring;
+
+use Aws\CommandInterface;
+use Aws\Credentials\CredentialsInterface;
+use Aws\Exception\AwsException;
+use Aws\ResponseContainerInterface;
+use Aws\ResultInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * @internal
+ */
+class ApiCallAttemptMonitoringMiddleware extends AbstractMonitoringMiddleware
+{
+
+    /**
+     * Standard middleware wrapper function with CSM options passed in.
+     *
+     * @param callable $credentialProvider
+     * @param mixed  $options
+     * @param string $region
+     * @param string $service
+     * @return callable
+     */
+    public static function wrap(
+        callable $credentialProvider,
+        $options,
+        $region,
+        $service
+    ) {
+        return function (callable $handler) use (
+            $credentialProvider,
+            $options,
+            $region,
+            $service
+        ) {
+            return new static(
+                $handler,
+                $credentialProvider,
+                $options,
+                $region,
+                $service
+            );
+        };
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function getRequestData(RequestInterface $request)
+    {
+        return [
+            'Fqdn' => $request->getUri()->getHost(),
+        ];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function getResponseData($klass)
+    {
+        if ($klass instanceof ResultInterface) {
+            return [
+                'AttemptLatency' => self::getResultAttemptLatency($klass),
+                'DestinationIp' => self::getResultDestinationIp($klass),
+                'DnsLatency' => self::getResultDnsLatency($klass),
+                'HttpStatusCode' => self::getResultHttpStatusCode($klass),
+                'XAmzId2' => self::getResultHeader($klass, 'x-amz-id-2'),
+                'XAmzRequestId' => self::getResultHeader($klass, 'x-amz-request-id'),
+                'XAmznRequestId' => self::getResultHeader($klass, 'x-amzn-RequestId'),
+            ];
+        }
+        if ($klass instanceof AwsException) {
+            return [
+                'AttemptLatency' => self::getAwsExceptionAttemptLatency($klass),
+                'AwsException' => substr(
+                    self::getAwsExceptionErrorCode($klass),
+                    0,
+                    128
+                ),
+                'AwsExceptionMessage' => substr(
+                    self::getAwsExceptionMessage($klass),
+                    0,
+                    512
+                ),
+                'DestinationIp' => self::getAwsExceptionDestinationIp($klass),
+                'DnsLatency' => self::getAwsExceptionDnsLatency($klass),
+                'HttpStatusCode' => self::getAwsExceptionHttpStatusCode($klass),
+                'XAmzId2' => self::getAwsExceptionHeader($klass, 'x-amz-id-2'),
+                'XAmzRequestId' => self::getAwsExceptionHeader(
+                    $klass,
+                    'x-amz-request-id'
+                ),
+                'XAmznRequestId' => self::getAwsExceptionHeader(
+                    $klass,
+                    'x-amzn-RequestId'
+                ),
+            ];
+        }
+        if ($klass instanceof \Exception) {
+            return [
+                'HttpStatusCode' => self::getExceptionHttpStatusCode($klass),
+                'SdkException' => substr(
+                    self::getExceptionCode($klass),
+                    0,
+                    128
+                ),
+                'SdkExceptionMessage' => substr(
+                    self::getExceptionMessage($klass),
+                    0,
+                    512
+                ),
+                'XAmzId2' => self::getExceptionHeader($klass, 'x-amz-id-2'),
+                'XAmzRequestId' => self::getExceptionHeader($klass, 'x-amz-request-id'),
+                'XAmznRequestId' => self::getExceptionHeader($klass, 'x-amzn-RequestId'),
+            ];
+        }
+
+        throw new \InvalidArgumentException('Parameter must be an instance of ResultInterface, AwsException or Exception.');
+    }
+
+    private static function getResultAttemptLatency(ResultInterface $result)
+    {
+        if (isset($result['@metadata']['transferStats']['http'])) {
+            $attempt = end($result['@metadata']['transferStats']['http']);
+            if (isset($attempt['total_time'])) {
+                return (int) floor($attempt['total_time'] * 1000);
+            }
+        }
+        return null;
+    }
+
+    private static function getResultDestinationIp(ResultInterface $result)
+    {
+        if (isset($result['@metadata']['transferStats']['http'])) {
+            $attempt = end($result['@metadata']['transferStats']['http']);
+            if (isset($attempt['primary_ip'])) {
+                return $attempt['primary_ip'];
+            }
+        }
+        return null;
+    }
+
+    private static function getResultDnsLatency(ResultInterface $result)
+    {
+        if (isset($result['@metadata']['transferStats']['http'])) {
+            $attempt = end($result['@metadata']['transferStats']['http']);
+            if (isset($attempt['namelookup_time'])) {
+                return (int) floor($attempt['namelookup_time'] * 1000);
+            }
+        }
+        return null;
+    }
+
+    private static function getResultHttpStatusCode(ResultInterface $result)
+    {
+        return $result['@metadata']['statusCode'];
+    }
+
+    private static function getAwsExceptionAttemptLatency(AwsException $e) {
+        $attempt = $e->getTransferInfo();
+        if (isset($attempt['total_time'])) {
+            return (int) floor($attempt['total_time'] * 1000);
+        }
+        return null;
+    }
+
+    private static function getAwsExceptionErrorCode(AwsException $e) {
+        return $e->getAwsErrorCode();
+    }
+
+    private static function getAwsExceptionMessage(AwsException $e) {
+        return $e->getAwsErrorMessage();
+    }
+
+    private static function getAwsExceptionDestinationIp(AwsException $e) {
+        $attempt = $e->getTransferInfo();
+        if (isset($attempt['primary_ip'])) {
+            return $attempt['primary_ip'];
+        }
+        return null;
+    }
+
+    private static function getAwsExceptionDnsLatency(AwsException $e) {
+        $attempt = $e->getTransferInfo();
+        if (isset($attempt['namelookup_time'])) {
+            return (int) floor($attempt['namelookup_time'] * 1000);
+        }
+        return null;
+    }
+
+    private static function getAwsExceptionHttpStatusCode(AwsException $e) {
+        $response = $e->getResponse();
+        if ($response !== null) {
+            return $response->getStatusCode();
+        }
+        return null;
+    }
+
+    private static function getExceptionHttpStatusCode(\Exception $e) {
+        if ($e instanceof ResponseContainerInterface) {
+            $response = $e->getResponse();
+            if ($response instanceof ResponseInterface) {
+                return $response->getStatusCode();
+            }
+        }
+        return null;
+    }
+
+    private static function getExceptionCode(\Exception $e) {
+        if (!($e instanceof AwsException)) {
+            return get_class($e);
+        }
+        return null;
+    }
+
+    private static function getExceptionMessage(\Exception $e) {
+        if (!($e instanceof AwsException)) {
+            return $e->getMessage();
+        }
+        return null;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function populateRequestEventData(
+        CommandInterface $cmd,
+        RequestInterface $request,
+        array $event
+    ) {
+        $event = parent::populateRequestEventData($cmd, $request, $event);
+        $event['Type'] = 'ApiCallAttempt';
+        return $event;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function populateResultEventData(
+        $result,
+        array $event
+    ) {
+        $event = parent::populateResultEventData($result, $event);
+
+        $provider = $this->credentialProvider;
+        /** @var CredentialsInterface $credentials */
+        $credentials = $provider()->wait();
+        $event['AccessKey'] = $credentials->getAccessKeyId();
+        $sessionToken = $credentials->getSecurityToken();
+        if ($sessionToken !== null) {
+            $event['SessionToken'] = $sessionToken;
+        }
+        if (empty($event['AttemptLatency'])) {
+            $event['AttemptLatency'] = (int) (floor(microtime(true) * 1000) - $event['Timestamp']);
+        }
+        return $event;
+    }
+}

vendor/aws/aws-sdk-php/src/ClientSideMonitoring/ApiCallMonitoringMiddleware.php

@@ -0,0 +1,175 @@
+<?php
+
+namespace Aws\ClientSideMonitoring;
+
+use Aws\CommandInterface;
+use Aws\Exception\AwsException;
+use Aws\MonitoringEventsInterface;
+use Aws\ResultInterface;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * @internal
+ */
+class ApiCallMonitoringMiddleware extends AbstractMonitoringMiddleware
+{
+    /**
+     * Api Call Attempt event keys for each Api Call event key
+     *
+     * @var array
+     */
+    private static $eventKeys = [
+        'FinalAwsException' => 'AwsException',
+        'FinalAwsExceptionMessage' => 'AwsExceptionMessage',
+        'FinalSdkException' => 'SdkException',
+        'FinalSdkExceptionMessage' => 'SdkExceptionMessage',
+        'FinalHttpStatusCode' => 'HttpStatusCode',
+    ];
+
+    /**
+     * Standard middleware wrapper function with CSM options passed in.
+     *
+     * @param callable $credentialProvider
+     * @param mixed  $options
+     * @param string $region
+     * @param string $service
+     * @return callable
+     */
+    public static function wrap(
+        callable $credentialProvider,
+        $options,
+        $region,
+        $service
+    ) {
+        return function (callable $handler) use (
+            $credentialProvider,
+            $options,
+            $region,
+            $service
+        ) {
+            return new static(
+                $handler,
+                $credentialProvider,
+                $options,
+                $region,
+                $service
+            );
+        };
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function getRequestData(RequestInterface $request)
+    {
+        return [];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function getResponseData($klass)
+    {
+        if ($klass instanceof ResultInterface) {
+            $data = [
+                'AttemptCount' => self::getResultAttemptCount($klass),
+                'MaxRetriesExceeded' => 0,
+            ];
+        } elseif ($klass instanceof \Exception) {
+            $data = [
+                'AttemptCount' => self::getExceptionAttemptCount($klass),
+                'MaxRetriesExceeded' => self::getMaxRetriesExceeded($klass),
+            ];
+        } else {
+            throw new \InvalidArgumentException('Parameter must be an instance of ResultInterface or Exception.');
+        }
+
+        return $data + self::getFinalAttemptData($klass);
+    }
+
+    private static function getResultAttemptCount(ResultInterface $result) {
+        if (isset($result['@metadata']['transferStats']['http'])) {
+            return count($result['@metadata']['transferStats']['http']);
+        }
+        return 1;
+    }
+
+    private static function getExceptionAttemptCount(\Exception $e) {
+        $attemptCount = 0;
+        if ($e instanceof MonitoringEventsInterface) {
+            foreach ($e->getMonitoringEvents() as $event) {
+                if (isset($event['Type']) &&
+                    $event['Type'] === 'ApiCallAttempt') {
+                    $attemptCount++;
+                }
+            }
+
+        }
+        return $attemptCount;
+    }
+
+    private static function getFinalAttemptData($klass)
+    {
+        $data = [];
+        if ($klass instanceof MonitoringEventsInterface) {
+            $finalAttempt = self::getFinalAttempt($klass->getMonitoringEvents());
+
+            if (!empty($finalAttempt)) {
+                foreach (self::$eventKeys as $callKey => $attemptKey) {
+                    if (isset($finalAttempt[$attemptKey])) {
+                        $data[$callKey] = $finalAttempt[$attemptKey];
+                    }
+                }
+            }
+        }
+
+        return $data;
+    }
+
+    private static function getFinalAttempt(array $events)
+    {
+        for (end($events); key($events) !== null; prev($events)) {
+            $current = current($events);
+            if (isset($current['Type'])
+                && $current['Type'] === 'ApiCallAttempt'
+            ) {
+                return $current;
+            }
+        }
+
+        return null;
+    }
+
+    private static function getMaxRetriesExceeded($klass)
+    {
+        if ($klass instanceof AwsException && $klass->isMaxRetriesExceeded()) {
+            return 1;
+        }
+        return 0;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function populateRequestEventData(
+        CommandInterface $cmd,
+        RequestInterface $request,
+        array $event
+    ) {
+        $event = parent::populateRequestEventData($cmd, $request, $event);
+        $event['Type'] = 'ApiCall';
+        return $event;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function populateResultEventData(
+        $result,
+        array $event
+    ) {
+        $event = parent::populateResultEventData($result, $event);
+        $event['Latency'] = (int) (floor(microtime(true) * 1000) - $event['Timestamp']);
+        return $event;
+    }
+}

vendor/aws/aws-sdk-php/src/ClientSideMonitoring/Configuration.php

@@ -0,0 +1,77 @@
+<?php
+namespace Aws\ClientSideMonitoring;
+
+class Configuration implements ConfigurationInterface
+{
+    private $clientId;
+    private $enabled;
+    private $host;
+    private $port;
+
+    /**
+     * Constructs a new Configuration object with the specified CSM options set.
+     *
+     * @param mixed $enabled
+     * @param string $host
+     * @param string|int $port
+     * @param string $clientId
+     */
+    public function __construct($enabled, $host, $port, $clientId = '')
+    {
+        $this->host = $host;
+        $this->port = filter_var($port, FILTER_VALIDATE_INT);
+        if ($this->port === false) {
+            throw new \InvalidArgumentException(
+                "CSM 'port' value must be an integer!");
+        }
+
+        // Unparsable $enabled flag errors on the side of disabling CSM
+        $this->enabled = filter_var($enabled, FILTER_VALIDATE_BOOLEAN);
+        $this->clientId = trim($clientId);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isEnabled()
+    {
+        return $this->enabled;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getClientId()
+    {
+        return $this->clientId;
+    }
+
+    /**
+     * /{@inheritdoc}
+     */
+    public function getHost()
+    {
+        return $this->host;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getPort()
+    {
+        return $this->port;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function toArray()
+    {
+        return [
+            'client_id' => $this->getClientId(),
+            'enabled' => $this->isEnabled(),
+            'host' => $this->getHost(),
+            'port' => $this->getPort()
+        ];
+    }
+}

vendor/aws/aws-sdk-php/src/ClientSideMonitoring/ConfigurationInterface.php

@@ -0,0 +1,44 @@
+<?php
+namespace Aws\ClientSideMonitoring;
+
+/**
+ * Provides access to client-side monitoring configuration options:
+ * 'client_id', 'enabled', 'host', 'port'
+ */
+interface ConfigurationInterface
+{
+    /**
+     * Checks whether or not client-side monitoring is enabled.
+     *
+     * @return bool
+     */
+    public function isEnabled();
+
+    /**
+     * Returns the Client ID, if available.
+     *
+     * @return string|null
+     */
+    public function getClientId();
+
+    /**
+     * Returns the configured host.
+     *
+     * @return string|null
+     */
+    public function getHost();
+
+    /**
+     * Returns the configured port.
+     *
+     * @return int|null
+     */
+    public function getPort();
+
+    /**
+     * Returns the configuration as an associative array.
+     *
+     * @return array
+     */
+    public function toArray();
+}

vendor/aws/aws-sdk-php/src/ClientSideMonitoring/ConfigurationProvider.php

@@ -0,0 +1,236 @@
+<?php
+namespace Aws\ClientSideMonitoring;
+
+use Aws\AbstractConfigurationProvider;
+use Aws\CacheInterface;
+use Aws\ClientSideMonitoring\Exception\ConfigurationException;
+use Aws\ConfigurationProviderInterface;
+use GuzzleHttp\Promise;
+use GuzzleHttp\Promise\PromiseInterface;
+
+/**
+ * A configuration provider is a function that accepts no arguments and returns
+ * a promise that is fulfilled with a {@see \Aws\ClientSideMonitoring\ConfigurationInterface}
+ * or rejected with an {@see \Aws\ClientSideMonitoring\Exception\ConfigurationException}.
+ *
+ * <code>
+ * use Aws\ClientSideMonitoring\ConfigurationProvider;
+ * $provider = ConfigurationProvider::defaultProvider();
+ * // Returns a ConfigurationInterface or throws.
+ * $config = $provider()->wait();
+ * </code>
+ *
+ * Configuration providers can be composed to create configuration using
+ * conditional logic that can create different configurations in different
+ * environments. You can compose multiple providers into a single provider using
+ * {@see Aws\ClientSideMonitoring\ConfigurationProvider::chain}. This function
+ * accepts providers as variadic arguments and returns a new function that will
+ * invoke each provider until a successful configuration is returned.
+ *
+ * <code>
+ * // First try an INI file at this location.
+ * $a = ConfigurationProvider::ini(null, '/path/to/file.ini');
+ * // Then try an INI file at this location.
+ * $b = ConfigurationProvider::ini(null, '/path/to/other-file.ini');
+ * // Then try loading from environment variables.
+ * $c = ConfigurationProvider::env();
+ * // Combine the three providers together.
+ * $composed = ConfigurationProvider::chain($a, $b, $c);
+ * // Returns a promise that is fulfilled with a configuration or throws.
+ * $promise = $composed();
+ * // Wait on the configuration to resolve.
+ * $config = $promise->wait();
+ * </code>
+ */
+class ConfigurationProvider extends AbstractConfigurationProvider
+    implements ConfigurationProviderInterface
+{
+    const DEFAULT_CLIENT_ID = '';
+    const DEFAULT_ENABLED = false;
+    const DEFAULT_HOST = '127.0.0.1';
+    const DEFAULT_PORT = 31000;
+    const ENV_CLIENT_ID = 'AWS_CSM_CLIENT_ID';
+    const ENV_ENABLED = 'AWS_CSM_ENABLED';
+    const ENV_HOST = 'AWS_CSM_HOST';
+    const ENV_PORT = 'AWS_CSM_PORT';
+    const ENV_PROFILE = 'AWS_PROFILE';
+
+    public static $cacheKey = 'aws_cached_csm_config';
+
+    protected static $interfaceClass = ConfigurationInterface::class;
+    protected static $exceptionClass = ConfigurationException::class;
+
+    /**
+     * Create a default config provider that first checks for environment
+     * variables, then checks for a specified profile in the environment-defined
+     * config file location (env variable is 'AWS_CONFIG_FILE', file location
+     * defaults to ~/.aws/config), then checks for the "default" profile in the
+     * environment-defined config file location, and failing those uses a default
+     * fallback set of configuration options.
+     *
+     * This provider is automatically wrapped in a memoize function that caches
+     * previously provided config options.
+     *
+     * @param array $config
+     *
+     * @return callable
+     */
+    public static function defaultProvider(array $config = [])
+    {
+        $configProviders = [self::env()];
+        if (
+            !isset($config['use_aws_shared_config_files'])
+            || $config['use_aws_shared_config_files'] != false
+        ) {
+            $configProviders[] = self::ini();
+        }
+        $configProviders[] = self::fallback();
+
+        $memo = self::memoize(
+            call_user_func_array([ConfigurationProvider::class, 'chain'], $configProviders)
+        );
+
+        if (isset($config['csm']) && $config['csm'] instanceof CacheInterface) {
+            return self::cache($memo, $config['csm'], self::$cacheKey);
+        }
+
+        return $memo;
+    }
+
+    /**
+     * Provider that creates CSM config from environment variables.
+     *
+     * @return callable
+     */
+    public static function env()
+    {
+        return function () {
+            // Use credentials from environment variables, if available
+            $enabled = getenv(self::ENV_ENABLED);
+            if ($enabled !== false) {
+                return Promise\Create::promiseFor(
+                    new Configuration(
+                        $enabled,
+                        getenv(self::ENV_HOST) ?: self::DEFAULT_HOST,
+                        getenv(self::ENV_PORT) ?: self::DEFAULT_PORT,
+                        getenv(self:: ENV_CLIENT_ID) ?: self::DEFAULT_CLIENT_ID
+                     )
+                );
+            }
+
+            return self::reject('Could not find environment variable CSM config'
+                . ' in ' . self::ENV_ENABLED. '/' . self::ENV_HOST . '/'
+                . self::ENV_PORT . '/' . self::ENV_CLIENT_ID);
+        };
+    }
+
+    /**
+     * Fallback config options when other sources are not set.
+     *
+     * @return callable
+     */
+    public static function fallback()
+    {
+        return function() {
+            return Promise\Create::promiseFor(
+                new Configuration(
+                    self::DEFAULT_ENABLED,
+                    self::DEFAULT_HOST,
+                    self::DEFAULT_PORT,
+                    self::DEFAULT_CLIENT_ID
+                )
+            );
+        };
+    }
+
+    /**
+     * Config provider that creates config using a config file whose location
+     * is specified by an environment variable 'AWS_CONFIG_FILE', defaulting to
+     * ~/.aws/config if not specified
+     *
+     * @param string|null $profile  Profile to use. If not specified will use
+     *                              the "default" profile.
+     * @param string|null $filename If provided, uses a custom filename rather
+     *                              than looking in the default directory.
+     *
+     * @return callable
+     */
+    public static function ini($profile = null, $filename = null)
+    {
+        $filename = $filename ?: (self::getDefaultConfigFilename());
+        $profile = $profile ?: (getenv(self::ENV_PROFILE) ?: 'aws_csm');
+
+        return function () use ($profile, $filename) {
+            if (!@is_readable($filename)) {
+                return self::reject("Cannot read CSM config from $filename");
+            }
+            $data = \Aws\parse_ini_file($filename, true);
+            if ($data === false) {
+                return self::reject("Invalid config file: $filename");
+            }
+            if (!isset($data[$profile])) {
+                return self::reject("'$profile' not found in config file");
+            }
+            if (!isset($data[$profile]['csm_enabled'])) {
+                return self::reject("Required CSM config values not present in
+                    INI profile '{$profile}' ({$filename})");
+            }
+
+            // host is optional
+            if (empty($data[$profile]['csm_host'])) {
+                $data[$profile]['csm_host'] = self::DEFAULT_HOST;
+            }
+
+            // port is optional
+            if (!filter_var($data[$profile]['csm_port'] ?? null, FILTER_VALIDATE_INT)) {
+                $data[$profile]['csm_port'] = self::DEFAULT_PORT;
+            }
+
+            // client_id is optional
+            if (empty($data[$profile]['csm_client_id'])) {
+                $data[$profile]['csm_client_id'] = self::DEFAULT_CLIENT_ID;
+            }
+
+            return Promise\Create::promiseFor(
+                new Configuration(
+                    $data[$profile]['csm_enabled'],
+                    $data[$profile]['csm_host'],
+                    $data[$profile]['csm_port'],
+                    $data[$profile]['csm_client_id']
+                )
+            );
+        };
+    }
+
+    /**
+     * Unwraps a configuration object in whatever valid form it is in,
+     * always returning a ConfigurationInterface object.
+     *
+     * @param  mixed $config
+     * @return ConfigurationInterface
+     * @throws \InvalidArgumentException
+     */
+    public static function unwrap($config)
+    {
+        if (is_callable($config)) {
+            $config = $config();
+        }
+        if ($config instanceof PromiseInterface) {
+            $config = $config->wait();
+        }
+        if ($config instanceof ConfigurationInterface) {
+            return $config;
+        } elseif (is_array($config) && isset($config['enabled'])) {
+            $client_id = isset($config['client_id']) ? $config['client_id']
+                : self::DEFAULT_CLIENT_ID;
+            $host = isset($config['host']) ? $config['host']
+                : self::DEFAULT_HOST;
+            $port = isset($config['port']) ? $config['port']
+                : self::DEFAULT_PORT;
+            return new Configuration($config['enabled'], $host, $port, $client_id);
+        }
+
+        throw new \InvalidArgumentException('Not a valid CSM configuration '
+            . 'argument.');
+    }
+}

vendor/aws/aws-sdk-php/src/ClientSideMonitoring/Exception/ConfigurationException.php

@@ -0,0 +1,15 @@
+<?php
+namespace Aws\ClientSideMonitoring\Exception;
+
+use Aws\HasMonitoringEventsTrait;
+use Aws\MonitoringEventsInterface;
+
+
+/**
+ * Represents an error interacting with configuration for client-side monitoring.
+ */
+class ConfigurationException extends \RuntimeException implements
+    MonitoringEventsInterface
+{
+    use HasMonitoringEventsTrait;
+}

vendor/aws/aws-sdk-php/src/ClientSideMonitoring/MonitoringMiddlewareInterface.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Aws\ClientSideMonitoring;
+
+use Aws\CommandInterface;
+use Aws\Exception\AwsException;
+use Aws\ResultInterface;
+use GuzzleHttp\Psr7\Request;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * @internal
+ */
+interface MonitoringMiddlewareInterface
+{
+
+    /**
+     * Data for event properties to be sent to the monitoring agent.
+     *
+     * @param RequestInterface $request
+     * @return array
+     */
+    public static function getRequestData(RequestInterface $request);
+
+
+    /**
+     * Data for event properties to be sent to the monitoring agent.
+     *
+     * @param ResultInterface|AwsException|\Exception $klass
+     * @return array
+     */
+    public static function getResponseData($klass);
+
+    public function __invoke(CommandInterface $cmd, RequestInterface $request);
+}

vendor/aws/aws-sdk-php/src/Command.php

@@ -0,0 +1,134 @@
+<?php
+namespace Aws;
+
+/**
+ * AWS command object.
+ */
+class Command implements CommandInterface
+{
+    use HasDataTrait;
+
+    /** @var string */
+    private $name;
+
+    /** @var HandlerList */
+    private $handlerList;
+
+    /** @var array */
+    private $authSchemes;
+
+    /** @var MetricsBuilder */
+    private $metricsBuilder;
+
+    /**
+     * Accepts an associative array of command options, including:
+     *
+     * - @http: (array) Associative array of transfer options.
+     *
+     * @param string      $name           Name of the command
+     * @param array       $args           Arguments to pass to the command
+     * @param HandlerList $list           Handler list
+     */
+    public function __construct(
+        $name,
+        array $args = [],
+        ?HandlerList $list = null,
+        ?MetricsBuilder $metricsBuilder = null
+    )
+    {
+        $this->name = $name;
+        $this->data = $args;
+        $this->handlerList = $list ?: new HandlerList();
+
+        if (!isset($this->data['@http'])) {
+            $this->data['@http'] = [];
+        }
+        if (!isset($this->data['@context'])) {
+            $this->data['@context'] = [];
+        }
+        $this->metricsBuilder = $metricsBuilder ?: new MetricsBuilder();
+    }
+
+    public function __clone()
+    {
+        $this->handlerList = clone $this->handlerList;
+    }
+
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    public function hasParam($name)
+    {
+        return array_key_exists($name, $this->data);
+    }
+
+    public function getHandlerList()
+    {
+        return $this->handlerList;
+    }
+
+    /**
+     * For overriding auth schemes on a per endpoint basis when using
+     * EndpointV2 provider. Intended for internal use only.
+     *
+     * @param array $authSchemes
+     *
+     * @deprecated In favor of using the @context property bag.
+     *             Auth Schemes are now accessible via the `signature_version` key
+     *             in a Command's context, if applicable. Auth Schemes set using
+     *             This method are no longer consumed.
+     *
+     * @internal
+     */
+    public function setAuthSchemes(array $authSchemes)
+    {
+        trigger_error(__METHOD__ . ' is deprecated.  Auth schemes '
+            . 'resolved using the service `auth` trait or via endpoint resolution '
+            . 'are now set in the command `@context` property.`'
+            , E_USER_WARNING
+        );
+
+        $this->authSchemes = $authSchemes;
+    }
+
+    /**
+     * Get auth schemes added to command as required
+     * for endpoint resolution
+     *
+     * @returns array
+     *
+     * @deprecated In favor of using the @context property bag.
+     *             Auth schemes are now accessible via the `signature_version` key
+     *             in a Command's context, if applicable.
+     */
+    public function getAuthSchemes()
+    {
+        trigger_error(__METHOD__ . ' is deprecated.  Auth schemes '
+        . 'resolved using the service `auth` trait or via endpoint resolution '
+        . 'can now be found in the command `@context` property.`'
+        , E_USER_WARNING
+        );
+
+        return $this->authSchemes ?: [];
+    }
+
+    /** @deprecated */
+    public function get($name)
+    {
+        return $this[$name];
+    }
+
+    /**
+     * Returns the metrics builder instance tied up to this command.
+     *
+     * @internal
+     *
+     * @return MetricsBuilder
+     */
+    public function getMetricsBuilder(): MetricsBuilder
+    {
+        return $this->metricsBuilder;
+    }
+}

vendor/aws/aws-sdk-php/src/CommandInterface.php

@@ -0,0 +1,42 @@
+<?php
+namespace Aws;
+
+/**
+ * A command object encapsulates the input parameters used to control the
+ * creation of a HTTP request and processing of a HTTP response.
+ *
+ * Using the toArray() method will return the input parameters of the command
+ * as an associative array.
+ */
+interface CommandInterface extends \ArrayAccess, \Countable, \IteratorAggregate
+{
+    /**
+     * Converts the command parameters to an array
+     *
+     * @return array
+     */
+    public function toArray();
+
+    /**
+     * Get the name of the command
+     *
+     * @return string
+     */
+    public function getName();
+
+    /**
+     * Check if the command has a parameter by name.
+     *
+     * @param string $name Name of the parameter to check
+     *
+     * @return bool
+     */
+    public function hasParam($name);
+
+    /**
+     * Get the handler list used to transfer the command.
+     *
+     * @return HandlerList
+     */
+    public function getHandlerList();
+}

vendor/aws/aws-sdk-php/src/CommandPool.php

@@ -0,0 +1,151 @@
+<?php
+namespace Aws;
+
+use GuzzleHttp\Promise\PromiseInterface;
+use GuzzleHttp\Promise\PromisorInterface;
+use GuzzleHttp\Promise\EachPromise;
+
+/**
+ * Sends and iterator of commands concurrently using a capped pool size.
+ *
+ * The pool will read command objects from an iterator until it is cancelled or
+ * until the iterator is consumed.
+ */
+class CommandPool implements PromisorInterface
+{
+    /** @var EachPromise */
+    private $each;
+
+    /**
+     * The CommandPool constructor accepts a hash of configuration options:
+     *
+     * - concurrency: (callable|int) Maximum number of commands to execute
+     *   concurrently. Provide a function to resize the pool dynamically. The
+     *   function will be provided the current number of pending requests and
+     *   is expected to return an integer representing the new pool size limit.
+     * - before: (callable) function to invoke before sending each command. The
+     *   before function accepts the command and the key of the iterator of the
+     *   command. You can mutate the command as needed in the before function
+     *   before sending the command.
+     * - fulfilled: (callable) Function to invoke when a promise is fulfilled.
+     *   The function is provided the result object, id of the iterator that the
+     *   result came from, and the aggregate promise that can be resolved/rejected
+     *   if you need to short-circuit the pool.
+     * - rejected: (callable) Function to invoke when a promise is rejected.
+     *   The function is provided an AwsException object, id of the iterator that
+     *   the exception came from, and the aggregate promise that can be
+     *   resolved/rejected if you need to short-circuit the pool.
+     * - preserve_iterator_keys: (bool) Retain the iterator key when generating
+     *   the commands.
+     *
+     * @param AwsClientInterface $client   Client used to execute commands.
+     * @param array|\Iterator    $commands Iterable that yields commands.
+     * @param array              $config   Associative array of options.
+     */
+    public function __construct(
+        AwsClientInterface $client,
+        $commands,
+        array $config = []
+    ) {
+        if (!isset($config['concurrency'])) {
+            $config['concurrency'] = 25;
+        }
+
+        $before = $this->getBefore($config);
+        $mapFn = function ($commands) use ($client, $before, $config) {
+            foreach ($commands as $key => $command) {
+                if (!($command instanceof CommandInterface)) {
+                    throw new \InvalidArgumentException('Each value yielded by '
+                        . 'the iterator must be an Aws\CommandInterface.');
+                }
+                if ($before) {
+                    $before($command, $key);
+                }
+                if (!empty($config['preserve_iterator_keys'])) {
+                    yield $key => $client->executeAsync($command);
+                } else {
+                    yield $client->executeAsync($command);
+                }
+            }
+        };
+
+        $this->each = new EachPromise($mapFn($commands), $config);
+    }
+
+    /**
+     * @return PromiseInterface
+     */
+    public function promise(): PromiseInterface
+    {
+        return $this->each->promise();
+    }
+
+    /**
+     * Executes a pool synchronously and aggregates the results of the pool
+     * into an indexed array in the same order as the passed in array.
+     *
+     * @param AwsClientInterface $client   Client used to execute commands.
+     * @param mixed              $commands Iterable that yields commands.
+     * @param array              $config   Configuration options.
+     *
+     * @return array
+     * @see \Aws\CommandPool::__construct for available configuration options.
+     */
+    public static function batch(
+        AwsClientInterface $client,
+        $commands,
+        array $config = []
+    ) {
+        $results = [];
+        self::cmpCallback($config, 'fulfilled', $results);
+        self::cmpCallback($config, 'rejected', $results);
+
+        return (new self($client, $commands, $config))
+            ->promise()
+            ->then(static function () use (&$results) {
+                ksort($results);
+                return $results;
+            })
+            ->wait();
+    }
+
+    /**
+     * @return callable
+     */
+    private function getBefore(array $config)
+    {
+        if (!isset($config['before'])) {
+            return null;
+        }
+
+        if (is_callable($config['before'])) {
+            return $config['before'];
+        }
+
+        throw new \InvalidArgumentException('before must be callable');
+    }
+
+    /**
+     * Adds an onFulfilled or onRejected callback that aggregates results into
+     * an array. If a callback is already present, it is replaced with the
+     * composed function.
+     *
+     * @param array $config
+     * @param       $name
+     * @param array $results
+     */
+    private static function cmpCallback(array &$config, $name, array &$results)
+    {
+        if (!isset($config[$name])) {
+            $config[$name] = function ($v, $k) use (&$results) {
+                $results[$k] = $v;
+            };
+        } else {
+            $currentFn = $config[$name];
+            $config[$name] = function ($v, $k) use (&$results, $currentFn) {
+                $currentFn($v, $k);
+                $results[$k] = $v;
+            };
+        }
+    }
+}

vendor/aws/aws-sdk-php/src/ConfigurationProviderInterface.php

@@ -0,0 +1,13 @@
+<?php
+namespace Aws;
+
+interface ConfigurationProviderInterface
+{
+    /**
+     * Create a default config provider
+     *
+     * @param array $config
+     * @return callable
+     */
+    public static function defaultProvider(array $config = []);
+}

vendor/aws/aws-sdk-php/src/Credentials/AssumeRoleCredentialProvider.php

@@ -0,0 +1,67 @@
+<?php
+namespace Aws\Credentials;
+
+use Aws\Exception\CredentialsException;
+use Aws\Result;
+use Aws\Sts\StsClient;
+use GuzzleHttp\Promise\PromiseInterface;
+
+/**
+ * Credential provider that provides credentials via assuming a role
+ * More Information, see: http://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerole
+ */
+class AssumeRoleCredentialProvider
+{
+    const ERROR_MSG = "Missing required 'AssumeRoleCredentialProvider' configuration option: ";
+
+    /** @var StsClient */
+    private $client;
+
+    /** @var array */
+    private $assumeRoleParams;
+
+    /**
+     * The constructor requires following configure parameters:
+     *  - client: a StsClient
+     *  - assume_role_params: Parameters used to make assumeRole call
+     *
+     * @param array $config Configuration options
+     * @throws \InvalidArgumentException
+     */
+    public function __construct(array $config = [])
+    {
+        if (!isset($config['assume_role_params'])) {
+            throw new \InvalidArgumentException(self::ERROR_MSG . "'assume_role_params'.");
+        }
+
+        if (!isset($config['client'])) {
+            throw new \InvalidArgumentException(self::ERROR_MSG . "'client'.");
+        }
+
+        $this->client = $config['client'];
+        $this->assumeRoleParams = $config['assume_role_params'];
+    }
+
+    /**
+     * Loads assume role credentials.
+     *
+     * @return PromiseInterface
+     */
+    public function __invoke()
+    {
+        $client = $this->client;
+        return $client->assumeRoleAsync($this->assumeRoleParams)
+            ->then(function (Result $result) {
+                return $this->client->createCredentials(
+                    $result,
+                    CredentialSources::STS_ASSUME_ROLE
+                );
+            })->otherwise(function (\RuntimeException $exception) {
+                throw new CredentialsException(
+                    "Error in retrieving assume role credentials.",
+                    0,
+                    $exception
+                );
+            });
+    }
+}

vendor/aws/aws-sdk-php/src/Credentials/AssumeRoleWithWebIdentityCredentialProvider.php

@@ -0,0 +1,201 @@
+<?php
+namespace Aws\Credentials;
+
+use Aws\Exception\AwsException;
+use Aws\Exception\CredentialsException;
+use Aws\Result;
+use Aws\Sts\StsClient;
+use GuzzleHttp\Promise;
+
+/**
+ * Credential provider that provides credentials via assuming a role with a web identity
+ * More Information, see: https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerolewithwebidentity
+ */
+class AssumeRoleWithWebIdentityCredentialProvider
+{
+    const ERROR_MSG = "Missing required 'AssumeRoleWithWebIdentityCredentialProvider' configuration option: ";
+    const ENV_RETRIES = 'AWS_METADATA_SERVICE_NUM_ATTEMPTS';
+
+    /** @var string */
+    private $tokenFile;
+
+    /** @var string */
+    private $arn;
+
+    /** @var string */
+    private $session;
+
+    /** @var StsClient */
+    private $client;
+
+    /** @var integer */
+    private $retries;
+
+    /** @var integer */
+    private $authenticationAttempts;
+
+    /** @var integer */
+    private $tokenFileReadAttempts;
+
+    /** @var string */
+    private $source;
+
+    /**
+     * The constructor attempts to load config from environment variables.
+     * If not set, the following config options are used:
+     *  - WebIdentityTokenFile: full path of token filename
+     *  - RoleArn: arn of role to be assumed
+     *  - SessionName: (optional) set by SDK if not provided
+     *  - source: To identify if the provider was sourced by a profile or
+     *    from environment definition. Default will be `sts_web_id_token`.
+     *
+     * @param array $config Configuration options
+     * @throws \InvalidArgumentException
+     */
+    public function __construct(array $config = [])
+    {
+        if (!isset($config['RoleArn'])) {
+            throw new \InvalidArgumentException(self::ERROR_MSG . "'RoleArn'.");
+        }
+        $this->arn = $config['RoleArn'];
+
+        if (!isset($config['WebIdentityTokenFile'])) {
+            throw new \InvalidArgumentException(self::ERROR_MSG . "'WebIdentityTokenFile'.");
+        }
+        $this->tokenFile = $config['WebIdentityTokenFile'];
+
+        if (!preg_match("/^\w\:|^\/|^\\\/", $this->tokenFile)) {
+            throw new \InvalidArgumentException("'WebIdentityTokenFile' must be an absolute path.");
+        }
+
+        $this->retries = (int) getenv(self::ENV_RETRIES) ?: (isset($config['retries']) ? $config['retries'] : 3);
+        $this->authenticationAttempts = 0;
+        $this->tokenFileReadAttempts = 0;
+        $this->session = $config['SessionName']
+            ?? 'aws-sdk-php-' . round(microtime(true) * 1000);
+
+        if (isset($config['client'])) {
+            $this->client = $config['client'];
+        } else {
+            $region = $config['region']
+                ?? getEnv(CredentialProvider::ENV_REGION)
+                ?: null;
+
+            $this->client = $this->createDefaultStsClient($region);
+        }
+
+        $this->source = $config['source']
+            ?? CredentialSources::STS_WEB_ID_TOKEN;
+    }
+
+    /**
+     * Loads assume role with web identity credentials.
+     *
+     * @return Promise\PromiseInterface
+     */
+    public function __invoke()
+    {
+        return Promise\Coroutine::of(function () {
+            $client = $this->client;
+            $result = null;
+            while ($result == null) {
+                try {
+                    $token = @file_get_contents($this->tokenFile);
+                    if (false === $token) {
+                        clearstatcache(true, dirname($this->tokenFile) . "/" . readlink($this->tokenFile));
+                        clearstatcache(true, dirname($this->tokenFile) . "/" . dirname(readlink($this->tokenFile)));
+                        clearstatcache(true, $this->tokenFile);
+                        if (!@is_readable($this->tokenFile)) {
+                            throw new CredentialsException(
+                                "Unreadable tokenfile at location {$this->tokenFile}"
+                            );
+                        }
+
+                        $token = @file_get_contents($this->tokenFile);
+                    }
+                    if (empty($token)) {
+                        if ($this->tokenFileReadAttempts < $this->retries) {
+                            sleep((int) pow(1.2, $this->tokenFileReadAttempts));
+                            $this->tokenFileReadAttempts++;
+                            continue;
+                        }
+                        throw new CredentialsException("InvalidIdentityToken from file: {$this->tokenFile}");
+                    }
+                } catch (\Exception $exception) {
+                    throw new CredentialsException(
+                        "Error reading WebIdentityTokenFile from " . $this->tokenFile,
+                        0,
+                        $exception
+                    );
+                }
+
+                $assumeParams = [
+                    'RoleArn' => $this->arn,
+                    'RoleSessionName' => $this->session,
+                    'WebIdentityToken' => $token
+                ];
+
+                try {
+                    $result = $client->assumeRoleWithWebIdentity($assumeParams);
+                } catch (AwsException $e) {
+                    if ($e->getAwsErrorCode() == 'InvalidIdentityToken') {
+                        if ($this->authenticationAttempts < $this->retries) {
+                            sleep((int) pow(1.2, $this->authenticationAttempts));
+                        } else {
+                            throw new CredentialsException(
+                                "InvalidIdentityToken, retries exhausted"
+                            );
+                        }
+                    } else {
+                        throw new CredentialsException(
+                            "Error assuming role from web identity credentials",
+                            0,
+                            $e
+                        );
+                    }
+                } catch (\Exception $e) {
+                    throw new CredentialsException(
+                        "Error retrieving web identity credentials: " . $e->getMessage()
+                        . " (" . $e->getCode() . ")"
+                    );
+                }
+                $this->authenticationAttempts++;
+            }
+
+            yield $this->client->createCredentials(
+                $result,
+                $this->source
+            );
+        });
+    }
+
+    /**
+     * @param string|null $region
+     *
+     * @return StsClient
+     */
+    private function createDefaultStsClient(
+        ?string $region
+    ): StsClient
+    {
+        if (empty($region)) {
+            $region = CredentialProvider::FALLBACK_REGION;
+            trigger_error(
+                'NOTICE: STS client created without explicit `region` configuration.' . PHP_EOL
+                . "Defaulting to {$region}. This fallback behavior may be removed." . PHP_EOL
+                . 'To avoid potential disruptions, configure a region using one of the following methods:' . PHP_EOL
+                . '(1) Pass `region` in the `$config` array when calling the provider,' . PHP_EOL
+                . '(2) Set the `AWS_REGION` environment variable.' . PHP_EOL
+                . 'OR provide an STS client in the `$config` array when creating the provider as `client`.' . PHP_EOL
+                . 'See: https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/assume-role-with-web-identity-provider.html'
+                . PHP_EOL,
+                E_USER_NOTICE
+            );
+        }
+
+        return new StsClient([
+            'credentials' => false,
+            'region' => $region
+        ]);
+    }
+}

vendor/aws/aws-sdk-php/src/Credentials/CredentialSources.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Aws\Credentials;
+
+/**
+ * @internal
+ */
+final class CredentialSources
+{
+    const STATIC = 'static';
+    const ENVIRONMENT = 'env';
+    const STS_WEB_ID_TOKEN = 'sts_web_id_token';
+    const ENVIRONMENT_STS_WEB_ID_TOKEN = 'env_sts_web_id_token';
+    const PROFILE_STS_WEB_ID_TOKEN = 'profile_sts_web_id_token';
+    const STS_ASSUME_ROLE = 'sts_assume_role';
+    const PROFILE = 'profile';
+    const IMDS = 'instance_profile_provider';
+    const ECS = 'ecs';
+    const PROFILE_SSO = 'profile_sso';
+    const PROFILE_SSO_LEGACY = 'profile_sso_legacy';
+    const PROFILE_PROCESS = 'profile_process';
+    const PROFILE_LOGIN = 'profile_login';
+}

vendor/aws/aws-sdk-php/src/Credentials/Credentials.php

@@ -0,0 +1,150 @@
+<?php
+namespace Aws\Credentials;
+
+use Aws\Identity\AwsCredentialIdentity;
+
+/**
+ * Basic implementation of the AWS Credentials interface that allows callers to
+ * pass in the AWS Access Key and AWS Secret Access Key in the constructor.
+ */
+class Credentials extends AwsCredentialIdentity implements
+    CredentialsInterface,
+    \Serializable
+{
+    private $key;
+    private $secret;
+    private $token;
+    private $expires;
+    private $accountId;
+    private $source;
+
+    /**
+     * Constructs a new BasicAWSCredentials object, with the specified AWS
+     * access key and AWS secret key
+     *
+     * @param string $key     AWS access key ID
+     * @param string $secret  AWS secret access key
+     * @param string $token   Security token to use
+     * @param int    $expires UNIX timestamp for when credentials expire
+     */
+    public function __construct(
+        $key,
+        $secret,
+        $token = null,
+        $expires = null,
+        $accountId = null,
+        $source = CredentialSources::STATIC
+    )
+    {
+        $this->key = trim((string) $key);
+        $this->secret = trim((string) $secret);
+        $this->token = $token;
+        $this->expires = $expires;
+        $this->accountId = $accountId;
+        $this->source = $source ?? CredentialSources::STATIC;
+    }
+
+    public static function __set_state(array $state)
+    {
+        return new self(
+            $state['key'],
+            $state['secret'],
+            $state['token'],
+            $state['expires'],
+            $state['accountId'],
+            $state['source'] ?? null
+        );
+    }
+
+    public function getAccessKeyId()
+    {
+        return $this->key;
+    }
+
+    public function getSecretKey()
+    {
+        return $this->secret;
+    }
+
+    public function getSecurityToken()
+    {
+        return $this->token;
+    }
+
+    public function getExpiration()
+    {
+        return $this->expires;
+    }
+
+    public function isExpired()
+    {
+        return $this->expires !== null && time() >= $this->expires;
+    }
+
+    public function getAccountId()
+    {
+        return $this->accountId;
+    }
+
+    public function getSource()
+    {
+        return $this->source;
+    }
+
+    public function toArray()
+    {
+        return [
+            'key'     => $this->key,
+            'secret'  => $this->secret,
+            'token'   => $this->token,
+            'expires' => $this->expires,
+            'accountId' =>  $this->accountId,
+            'source' => $this->source
+        ];
+    }
+
+    public function serialize()
+    {
+        return json_encode($this->__serialize());
+    }
+
+    public function unserialize($serialized)
+    {
+        $data = json_decode($serialized, true);
+
+        $this->__unserialize($data);
+    }
+
+    public function __serialize()
+    {
+        return $this->toArray();
+    }
+
+    public function __unserialize($data)
+    {
+        $this->key = $data['key'];
+        $this->secret = $data['secret'];
+        $this->token = $data['token'];
+        $this->expires = $data['expires'];
+        $this->accountId = $data['accountId'] ?? null;
+        $this->source = $data['source'] ?? null;
+    }
+
+    /**
+     * Internal-only. Used when IMDS is unreachable
+     * or returns expires credentials.
+     *
+     * @internal
+     */
+    public function extendExpiration() {
+        $extension = mt_rand(5, 10);
+        $this->expires = time() + $extension * 60;
+
+        $message = <<<EOT
+Attempting credential expiration extension due to a credential service 
+availability issue. A refresh of these credentials will be attempted again 
+after {$extension} minutes.\n
+EOT;
+        trigger_error($message, E_USER_WARNING);
+    }
+}

vendor/aws/aws-sdk-php/src/Credentials/CredentialsInterface.php

@@ -0,0 +1,52 @@
+<?php
+namespace Aws\Credentials;
+
+/**
+ * Provides access to the AWS credentials used for accessing AWS services: AWS
+ * access key ID, secret access key, and security token. These credentials are
+ * used to securely sign requests to AWS services.
+ */
+interface CredentialsInterface
+{
+    /**
+     * Returns the AWS access key ID for this credentials object.
+     *
+     * @return string
+     */
+    public function getAccessKeyId();
+
+    /**
+     * Returns the AWS secret access key for this credentials object.
+     *
+     * @return string
+     */
+    public function getSecretKey();
+
+    /**
+     * Get the associated security token if available
+     *
+     * @return string|null
+     */
+    public function getSecurityToken();
+
+    /**
+     * Get the UNIX timestamp in which the credentials will expire
+     *
+     * @return int|null
+     */
+    public function getExpiration();
+
+    /**
+     * Check if the credentials are expired
+     *
+     * @return bool
+     */
+    public function isExpired();
+
+    /**
+     * Converts the credentials to an associative array.
+     *
+     * @return array
+     */
+    public function toArray();
+}

vendor/aws/aws-sdk-php/src/Credentials/CredentialsUtils.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Aws\Credentials;
+
+final class CredentialsUtils
+{
+    /**
+     * Determines whether a given host
+     * is a loopback address.
+     *
+     * @param $host
+     *
+     * @return bool
+     */
+    public static function isLoopBackAddress($host): bool
+    {
+        if (!filter_var($host, FILTER_VALIDATE_IP)) {
+            return false;
+        }
+
+        if (filter_var($host, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)) {
+            if ($host === '::1') {
+                return true;
+            }
+
+            return false;
+        }
+
+        $loopbackStart = ip2long('127.0.0.0');
+        $loopbackEnd = ip2long('127.255.255.255');
+        $ipLong = ip2long($host);
+
+        return ($ipLong >= $loopbackStart && $ipLong <= $loopbackEnd);
+    }
+}