FM / src

/home/techb158/ileadtechnology.com/vendor/aws/aws-sdk-php/src/

/home/techb158/ileadtechnology.com/vendor/aws/aws-sdk-php/src

Name	Size	Mode	Actions
AccessAnalyzer/	-	0755	rm
Account/	-	0755	rm
Acm/	-	0755	rm
ACMPCA/	-	0755	rm
AlexaForBusiness/	-	0755	rm
Amplify/	-	0755	rm
AmplifyBackend/	-	0755	rm
AmplifyUIBuilder/	-	0755	rm
Api/	-	0755	rm
ApiGateway/	-	0755	rm
ApiGatewayManagementApi/	-	0755	rm
ApiGatewayV2/	-	0755	rm
AppConfig/	-	0755	rm
AppConfigData/	-	0755	rm
AppFabric/	-	0755	rm
Appflow/	-	0755	rm
AppIntegrationsService/	-	0755	rm
ApplicationAutoScaling/	-	0755	rm
ApplicationCostProfiler/	-	0755	rm
ApplicationDiscoveryService/	-	0755	rm
ApplicationInsights/	-	0755	rm
AppMesh/	-	0755	rm
AppRegistry/	-	0755	rm
AppRunner/	-	0755	rm
Appstream/	-	0755	rm
AppSync/	-	0755	rm
ARCZonalShift/	-	0755	rm
Arn/	-	0755	rm
Athena/	-	0755	rm
AuditManager/	-	0755	rm
AugmentedAIRuntime/	-	0755	rm
AutoScaling/	-	0755	rm
AutoScalingPlans/	-	0755	rm
Backup/	-	0755	rm
BackupGateway/	-	0755	rm
BackupStorage/	-	0755	rm
Batch/	-	0755	rm
Bedrock/	-	0755	rm
BedrockRuntime/	-	0755	rm
BillingConductor/	-	0755	rm
Braket/	-	0755	rm
Budgets/	-	0755	rm
Chime/	-	0755	rm
ChimeSDKIdentity/	-	0755	rm
ChimeSDKMediaPipelines/	-	0755	rm
ChimeSDKMeetings/	-	0755	rm
ChimeSDKMessaging/	-	0755	rm
ChimeSDKVoice/	-	0755	rm
CleanRooms/	-	0755	rm
ClientSideMonitoring/	-	0755	rm
Cloud9/	-	0755	rm
CloudControlApi/	-	0755	rm
CloudDirectory/	-	0755	rm
CloudFormation/	-	0755	rm
CloudFront/	-	0755	rm
CloudHsm/	-	0755	rm
CloudHSMV2/	-	0755	rm
CloudSearch/	-	0755	rm
CloudSearchDomain/	-	0755	rm
CloudTrail/	-	0755	rm
CloudTrailData/	-	0755	rm
CloudWatch/	-	0755	rm
CloudWatchEvents/	-	0755	rm
CloudWatchEvidently/	-	0755	rm
CloudWatchLogs/	-	0755	rm
CloudWatchRUM/	-	0755	rm
CodeArtifact/	-	0755	rm
CodeBuild/	-	0755	rm
CodeCatalyst/	-	0755	rm
CodeCommit/	-	0755	rm
CodeDeploy/	-	0755	rm
CodeGuruProfiler/	-	0755	rm
CodeGuruReviewer/	-	0755	rm
CodeGuruSecurity/	-	0755	rm
CodePipeline/	-	0755	rm
CodeStar/	-	0755	rm
CodeStarconnections/	-	0755	rm
CodeStarNotifications/	-	0755	rm
CognitoIdentity/	-	0755	rm
CognitoIdentityProvider/	-	0755	rm
CognitoSync/	-	0755	rm
Comprehend/	-	0755	rm
ComprehendMedical/	-	0755	rm
ComputeOptimizer/	-	0755	rm
ConfigService/	-	0755	rm
Configuration/	-	0755	rm
Connect/	-	0755	rm
ConnectCampaignService/	-	0755	rm
ConnectCases/	-	0755	rm
ConnectContactLens/	-	0755	rm
ConnectParticipant/	-	0755	rm
ConnectWisdomService/	-	0755	rm
ControlTower/	-	0755	rm
CostandUsageReportService/	-	0755	rm
CostExplorer/	-	0755	rm
Credentials/	-	0755	rm
Crypto/	-	0755	rm
CustomerProfiles/	-	0755	rm
data/	-	0755	rm
DatabaseMigrationService/	-	0755	rm
DataExchange/	-	0755	rm
DataPipeline/	-	0755	rm
DataSync/	-	0755	rm
DataZone/	-	0755	rm
DAX/	-	0755	rm
DefaultsMode/	-	0755	rm
Detective/	-	0755	rm
DeviceFarm/	-	0755	rm
DevOpsGuru/	-	0755	rm
DirectConnect/	-	0755	rm
DirectoryService/	-	0755	rm
DLM/	-	0755	rm
DocDB/	-	0755	rm
DocDBElastic/	-	0755	rm
drs/	-	0755	rm
DynamoDb/	-	0755	rm
DynamoDbStreams/	-	0755	rm
EBS/	-	0755	rm
Ec2/	-	0755	rm
EC2InstanceConnect/	-	0755	rm
Ecr/	-	0755	rm
ECRPublic/	-	0755	rm
Ecs/	-	0755	rm
Efs/	-	0755	rm
EKS/	-	0755	rm
ElastiCache/	-	0755	rm
ElasticBeanstalk/	-	0755	rm
ElasticInference/	-	0755	rm
ElasticLoadBalancing/	-	0755	rm
ElasticLoadBalancingV2/	-	0755	rm
ElasticsearchService/	-	0755	rm
ElasticTranscoder/	-	0755	rm
Emr/	-	0755	rm
EMRContainers/	-	0755	rm
EMRServerless/	-	0755	rm
Endpoint/	-	0755	rm
EndpointDiscovery/	-	0755	rm
EndpointV2/	-	0755	rm
EntityResolution/	-	0755	rm
EventBridge/	-	0755	rm
Exception/	-	0755	rm
finspace/	-	0755	rm
FinSpaceData/	-	0755	rm
Firehose/	-	0755	rm
FIS/	-	0755	rm
FMS/	-	0755	rm
ForecastQueryService/	-	0755	rm
ForecastService/	-	0755	rm
FraudDetector/	-	0755	rm
FSx/	-	0755	rm
GameLift/	-	0755	rm
Glacier/	-	0755	rm
GlobalAccelerator/	-	0755	rm
Glue/	-	0755	rm
GlueDataBrew/	-	0755	rm
Greengrass/	-	0755	rm
GreengrassV2/	-	0755	rm
GroundStation/	-	0755	rm
GuardDuty/	-	0755	rm
Handler/	-	0755	rm
Health/	-	0755	rm
HealthLake/	-	0755	rm
Honeycode/	-	0755	rm
Iam/	-	0755	rm
IdentityStore/	-	0755	rm
imagebuilder/	-	0755	rm
ImportExport/	-	0755	rm
Inspector/	-	0755	rm
Inspector2/	-	0755	rm
InternetMonitor/	-	0755	rm
Iot/	-	0755	rm
IoT1ClickDevicesService/	-	0755	rm
IoT1ClickProjects/	-	0755	rm
IoTAnalytics/	-	0755	rm
IotDataPlane/	-	0755	rm
IoTDeviceAdvisor/	-	0755	rm
IoTEvents/	-	0755	rm
IoTEventsData/	-	0755	rm
IoTFleetHub/	-	0755	rm
IoTFleetWise/	-	0755	rm
IoTJobsDataPlane/	-	0755	rm
IoTRoboRunner/	-	0755	rm
IoTSecureTunneling/	-	0755	rm
IoTSiteWise/	-	0755	rm
IoTThingsGraph/	-	0755	rm
IoTTwinMaker/	-	0755	rm
IoTWireless/	-	0755	rm
IVS/	-	0755	rm
ivschat/	-	0755	rm
IVSRealTime/	-	0755	rm
Kafka/	-	0755	rm
KafkaConnect/	-	0755	rm
kendra/	-	0755	rm
KendraRanking/	-	0755	rm
Keyspaces/	-	0755	rm
Kinesis/	-	0755	rm
KinesisAnalytics/	-	0755	rm
KinesisAnalyticsV2/	-	0755	rm
KinesisVideo/	-	0755	rm
KinesisVideoArchivedMedia/	-	0755	rm
KinesisVideoMedia/	-	0755	rm
KinesisVideoSignalingChannels/	-	0755	rm
KinesisVideoWebRTCStorage/	-	0755	rm
Kms/	-	0755	rm
LakeFormation/	-	0755	rm
Lambda/	-	0755	rm
LexModelBuildingService/	-	0755	rm
LexModelsV2/	-	0755	rm
LexRuntimeService/	-	0755	rm
LexRuntimeV2/	-	0755	rm
LicenseManager/	-	0755	rm
LicenseManagerLinuxSubscriptions/	-	0755	rm
LicenseManagerUserSubscriptions/	-	0755	rm
Lightsail/	-	0755	rm
LocationService/	-	0755	rm
LookoutEquipment/	-	0755	rm
LookoutforVision/	-	0755	rm
LookoutMetrics/	-	0755	rm
MachineLearning/	-	0755	rm
Macie/	-	0755	rm
Macie2/	-	0755	rm
MainframeModernization/	-	0755	rm
ManagedBlockchain/	-	0755	rm
ManagedBlockchainQuery/	-	0755	rm
ManagedGrafana/	-	0755	rm
MarketplaceCatalog/	-	0755	rm
MarketplaceCommerceAnalytics/	-	0755	rm
MarketplaceEntitlementService/	-	0755	rm
MarketplaceMetering/	-	0755	rm
MediaConnect/	-	0755	rm
MediaConvert/	-	0755	rm
MediaLive/	-	0755	rm
MediaPackage/	-	0755	rm
MediaPackageV2/	-	0755	rm
MediaPackageVod/	-	0755	rm
MediaStore/	-	0755	rm
MediaStoreData/	-	0755	rm
MediaTailor/	-	0755	rm
MedicalImaging/	-	0755	rm
MemoryDB/	-	0755	rm
mgn/	-	0755	rm
MigrationHub/	-	0755	rm
MigrationHubConfig/	-	0755	rm
MigrationHubOrchestrator/	-	0755	rm
MigrationHubRefactorSpaces/	-	0755	rm
MigrationHubStrategyRecommendations/	-	0755	rm
Mobile/	-	0755	rm
MQ/	-	0755	rm
MTurk/	-	0755	rm
Multipart/	-	0755	rm
MWAA/	-	0755	rm
Neptune/	-	0755	rm
Neptunedata/	-	0755	rm
NetworkFirewall/	-	0755	rm
NetworkManager/	-	0755	rm
NimbleStudio/	-	0755	rm
OAM/	-	0755	rm
Omics/	-	0755	rm
OpenSearchServerless/	-	0755	rm
OpenSearchService/	-	0755	rm
OpsWorks/	-	0755	rm
OpsWorksCM/	-	0755	rm
Organizations/	-	0755	rm
OSIS/	-	0755	rm
Outposts/	-	0755	rm
Panorama/	-	0755	rm
PaymentCryptography/	-	0755	rm
PaymentCryptographyData/	-	0755	rm
PcaConnectorAd/	-	0755	rm
Personalize/	-	0755	rm
PersonalizeEvents/	-	0755	rm
PersonalizeRuntime/	-	0755	rm
PI/	-	0755	rm
Pinpoint/	-	0755	rm
PinpointEmail/	-	0755	rm
PinpointSMSVoice/	-	0755	rm
PinpointSMSVoiceV2/	-	0755	rm
Pipes/	-	0755	rm
Polly/	-	0755	rm
Pricing/	-	0755	rm
PrivateNetworks/	-	0755	rm
PrometheusService/	-	0755	rm
Proton/	-	0755	rm
QLDB/	-	0755	rm
QLDBSession/	-	0755	rm
QuickSight/	-	0755	rm
RAM/	-	0755	rm
Rds/	-	0755	rm
RDSDataService/	-	0755	rm
RecycleBin/	-	0755	rm
Redshift/	-	0755	rm
RedshiftDataAPIService/	-	0755	rm
RedshiftServerless/	-	0755	rm
Rekognition/	-	0755	rm
ResilienceHub/	-	0755	rm
ResourceExplorer2/	-	0755	rm
ResourceGroups/	-	0755	rm
ResourceGroupsTaggingAPI/	-	0755	rm
Retry/	-	0755	rm
RoboMaker/	-	0755	rm
RolesAnywhere/	-	0755	rm
Route53/	-	0755	rm
Route53Domains/	-	0755	rm
Route53RecoveryCluster/	-	0755	rm
Route53RecoveryControlConfig/	-	0755	rm
Route53RecoveryReadiness/	-	0755	rm
Route53Resolver/	-	0755	rm
S3/	-	0755	rm
S3Control/	-	0755	rm
S3Outposts/	-	0755	rm
SageMaker/	-	0755	rm
SagemakerEdgeManager/	-	0755	rm
SageMakerFeatureStoreRuntime/	-	0755	rm
SageMakerGeospatial/	-	0755	rm
SageMakerMetrics/	-	0755	rm
SageMakerRuntime/	-	0755	rm
SavingsPlans/	-	0755	rm
Scheduler/	-	0755	rm
Schemas/	-	0755	rm
Script/	-	0755	rm
SecretsManager/	-	0755	rm
SecurityHub/	-	0755	rm
SecurityLake/	-	0755	rm
ServerlessApplicationRepository/	-	0755	rm
ServiceCatalog/	-	0755	rm
ServiceDiscovery/	-	0755	rm
ServiceQuotas/	-	0755	rm
Ses/	-	0755	rm
SesV2/	-	0755	rm
Sfn/	-	0755	rm
Shield/	-	0755	rm
Signature/	-	0755	rm
signer/	-	0755	rm
SimSpaceWeaver/	-	0755	rm
Sms/	-	0755	rm
SnowBall/	-	0755	rm
SnowDeviceManagement/	-	0755	rm
Sns/	-	0755	rm
Sqs/	-	0755	rm
Ssm/	-	0755	rm
SSMContacts/	-	0755	rm
SSMIncidents/	-	0755	rm
SsmSap/	-	0755	rm
SSO/	-	0755	rm
SSOAdmin/	-	0755	rm
SSOOIDC/	-	0755	rm
StorageGateway/	-	0755	rm
Sts/	-	0755	rm
Support/	-	0755	rm
SupportApp/	-	0755	rm
Swf/	-	0755	rm
Synthetics/	-	0755	rm
Textract/	-	0755	rm
TimestreamQuery/	-	0755	rm
TimestreamWrite/	-	0755	rm
Tnb/	-	0755	rm
Token/	-	0755	rm
TranscribeService/	-	0755	rm
Transfer/	-	0755	rm
Translate/	-	0755	rm
VerifiedPermissions/	-	0755	rm
VoiceID/	-	0755	rm
VPCLattice/	-	0755	rm
Waf/	-	0755	rm
WafRegional/	-	0755	rm
WAFV2/	-	0755	rm
WellArchitected/	-	0755	rm
WorkDocs/	-	0755	rm
WorkLink/	-	0755	rm
WorkMail/	-	0755	rm
WorkMailMessageFlow/	-	0755	rm
WorkSpaces/	-	0755	rm
WorkSpacesWeb/	-	0755	rm
XRay/	-	0755	rm
AbstractConfigurationProvider.php	4572	0644	edit dl rm
AwsClient.php	25384	0644	edit dl rm
AwsClientInterface.php	5529	0644	edit dl rm
AwsClientTrait.php	2733	0644	edit dl rm
CacheInterface.php	755	0644	edit dl rm
ClientResolver.php	53281	0644	edit dl rm
Command.php	2018	0644	edit dl rm
CommandInterface.php	946	0644	edit dl rm
CommandPool.php	5360	0644	edit dl rm
ConfigurationProviderInterface.php	246	0644	edit dl rm
DoctrineCacheAdapter.php	989	0644	edit dl rm
EndpointParameterMiddleware.php	2799	0644	edit dl rm
functions.php	15578	0644	edit dl rm
HandlerList.php	13560	0644	edit dl rm
HasDataTrait.php	1495	0644	edit dl rm
HashingStream.php	1589	0644	edit dl rm
HashInterface.php	531	0644	edit dl rm
HasMonitoringEventsTrait.php	869	0644	edit dl rm
History.php	3996	0644	edit dl rm
IdempotencyTokenMiddleware.php	3782	0644	edit dl rm
InputValidationMiddleware.php	2494	0644	edit dl rm
JsonCompiler.php	478	0644	edit dl rm
LruArrayCache.php	2272	0644	edit dl rm
Middleware.php	15880	0644	edit dl rm
MockHandler.php	4190	0644	edit dl rm
MonitoringEventsInterface.php	742	0644	edit dl rm
MultiRegionClient.php	9003	0644	edit dl rm
PhpHash.php	1849	0644	edit dl rm
PresignUrlMiddleware.php	4644	0644	edit dl rm
Psr16CacheAdapter.php	572	0644	edit dl rm
PsrCacheAdapter.php	742	0644	edit dl rm
RequestCompressionMiddleware.php	4925	0644	edit dl rm
ResponseContainerInterface.php	246	0644	edit dl rm
Result.php	1170	0644	edit dl rm
ResultInterface.php	1372	0644	edit dl rm
ResultPaginator.php	6013	0644	edit dl rm
RetryMiddleware.php	8673	0644	edit dl rm
RetryMiddlewareV2.php	11951	0644	edit dl rm
Sdk.php	63366	0644	edit dl rm
StreamRequestPayloadMiddleware.php	2632	0644	edit dl rm
TraceMiddleware.php	12609	0644	edit dl rm
Waiter.php	8627	0644	edit dl rm
WrappedHttpHandler.php	7162	0644	edit dl rm

Edit: /home/techb158/ileadtechnology.com/vendor/aws/aws-sdk-php/src/AwsClient.php (25384B)

<?php
namespace Aws;

use Aws\Api\ApiProvider;
use Aws\Api\DocModel;
use Aws\Api\Service;
use Aws\EndpointDiscovery\EndpointDiscoveryMiddleware;
use Aws\EndpointV2\EndpointProviderV2;
use Aws\Exception\AwsException;
use Aws\Signature\SignatureProvider;
use GuzzleHttp\Psr7\Uri;

/**
 * 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 $endpoint;

/** @var Service */
    private $api;

/** @var callable */
    private $signatureProvider;

/** @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).
     *
     * @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->endpoint = new Uri($config['endpoint']);
        $this->credentialProvider = $config['credentials'];
        $this->tokenProvider = $config['token'];
        $this->region = isset($config['region']) ? $config['region'] : null;
        $this->config = $config['config'];
        $this->setClientBuiltIns($args);
        $this->clientContextParams = $this->setClientContextParams($args);
        $this->defaultRequestOptions = $config['http'];
        $this->endpointProvider = $config['endpoint_provider'];
        $this->serializer = $config['serializer'];
        $this->addSignatureMiddleware();
        $this->addInvocationId();
        $this->addEndpointParameterMiddleware($args);
        $this->addEndpointDiscoveryMiddleware($config, $args);
        $this->addRequestCompressionMiddleware($config);
        $this->loadAliases();
        $this->addStreamRequestPayload();
        $this->addRecursionDetection();
        $this->addRequestBuilder();

if (isset($args['with_resolved'])) {
            $args['with_resolved']($config);
        }
    }

public function getHandlerList()
    {
        return $this->handlerList;
    }

public function getConfig($option = null)
    {
        return $option === null
            ? $this->config
            : (isset($this->config[$option])
                ? $this->config[$option]
                : null);
    }

public function getCredentials()
    {
        $fn = $this->credentialProvider;
        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()
    {
        $api = $this->getApi();
        $provider = $this->signatureProvider;
        $version = $this->config['signature_version'];
        $name = $this->config['signing_name'];
        $region = $this->config['signing_region'];

$resolver = static function (
            CommandInterface $c
        ) use ($api, $provider, $name, $region, $version) {
            if (!empty($c['@context']['signing_region'])) {
                $region = $c['@context']['signing_region'];
            }
            if (!empty($c['@context']['signing_service'])) {
                $name = $c['@context']['signing_service'];
            }

$authType = $api->getOperation($c->getName())['authtype'];
            switch ($authType){
                case 'none':
                    $version = 'anonymous';
                    break;
                case 'v4-unsigned-body':
                    $version = 'v4-unsigned-body';
                    break;
                case 'bearer':
                    $version = 'bearer';
                    break;
            }
            if (isset($c['@context']['signature_version'])) {
                if ($c['@context']['signature_version'] == 'v4a') {
                    $version = 'v4a';
                }
            }
            if (!empty($endpointAuthSchemes = $c->getAuthSchemes())) {
                $version = $endpointAuthSchemes['version'];
                $name = isset($endpointAuthSchemes['name']) ?
                    $endpointAuthSchemes['name'] : $name;
                $region = isset($endpointAuthSchemes['region']) ?
                    $endpointAuthSchemes['region'] : $region;
            }
            return SignatureProvider::resolve($provider, $version, $name, $region);
        };
        $this->handlerList->appendSign(
            Middleware::signer($this->credentialProvider, $resolver, $this->tokenProvider),
            'signer'
        );
    }

private function addRequestCompressionMiddleware($config)
    {
        if (empty($config['disable_request_compression'])) {
            $list = $this->getHandlerList();
            $list->appendBuild(
                RequestCompressionMiddleware::wrap($config),
                'request-compression'
            );
        }
    }

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'
        );
    }

/**
     * Adds the `builder` middleware such that a client's endpoint
     * provider and endpoint resolution arguments can be passed.
     */
    private function addRequestBuilder()
    {
        $handlerList = $this->getHandlerList();
        $serializer = $this->serializer;
        $endpointProvider = $this->endpointProvider;
        $endpointArgs = $this->getEndpointProviderArgs();

$handlerList->prependBuild(
            Middleware::requestBuilder(
                $serializer,
                $endpointProvider,
                $endpointArgs
            ),
            'builderV2'
        );
    }

/**
     * 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])) {
                   $result[$paramName] = $args[$paramName];
               }
            }
        }
        return $resolvedParams;
    }

/**
     * Retrieves and sets default values used for endpoint resolution.
     */
    private function setClientBuiltIns($args)
    {
        $builtIns = [];
        $config = $this->getConfig();
        $service = $args['service'];

$builtIns['SDK::Endpoint'] = isset($args['endpoint']) ? $args['endpoint'] : null;
        $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'];
        }
        $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() {
        $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);
    }
}

cmd: