view release on metacpan or  search on metacpan

lib/AWS/CLIWrapper.pm  view on Meta::CPAN

            # Temporary disable __DIE__ handler to prevent the
            # exception from decode() from catching by outer
            # __DIE__ handler.
            local $SIG{__DIE__} = sub {};

            $self->json->decode($json);
        };
        if ($@) {
            if ($ENV{AWSCLI_DEBUG}) {
                warn $@;
                warn qq|stdout: "$ret->{stdout}"|;
                warn qq|err_msg: "$ret->{err_msg}"|;
            }
            return $json || 'success';
        }
        return $ret;
    } else {
        my $stdout_str = $ret->{stdout};
        if ($stdout_str && $stdout_str =~ /^{/) {
            my $json = $stdout_str;
            warn sprintf("%s.%s[%s]: %s\n",
                         $service, $operation, 'NG', $json,
                        ) if $ENV{AWSCLI_DEBUG};
            my($ret) = $self->json->decode_prefix($json);
            if (exists $ret->{Errors} && ref($ret->{Errors}) eq 'ARRAY') {
                $Error = $ret->{Errors}[0];
            } elsif (exists $ret->{Response}{Errors}{Error}) {
                # old structure (maybe botocore < 0.7.0)
                $Error = $ret->{Response}{Errors}{Error};
            } else {
                $Error = { Message => 'Unknown', Code => 'Unknown' };
            }
        } else {
            my $msg = $ret->{err_msg};
            warn sprintf("%s.%s[%s]: %s\n",
                         $service, $operation, 'NG', $msg,
                        ) if $ENV{AWSCLI_DEBUG};
            $Error = { Message => $msg, Code => 'Unknown' };
        }

        return;
    }
}

# aws help | col -b | perl -ne 'if (/^AVAILABLE/.../^[A-Z]/) {  s/^\s+o\s+// or next; chomp; next if $_ eq 'help'; my $sn = $_; $sn =~ s/-/_/g; printf "sub %-18s { shift->_execute('"'"'%s'"'"', \@_) }\n", $sn, $_ }'
# aws help | col -b | perl -ne 'if (/^AVAILABLE/.../^[A-Z]/) {  s/^\s+o\s+// or next; chomp; next if $_ eq 'help'; my $sn = $_; $sn =~ s/-/_/g; printf "=item B<%s>(\$operation:Str, \$param:HashRef, %%opt:Hash)\n\n", $sn}'
# =item B<s3>($operation:Str, $path:ArrayRef, $param:HashRef, %opt:Hash)
sub accessanalyzer     { shift->_execute('accessanalyzer', @_) }
sub account            { shift->_execute('account', @_) }
sub acm                { shift->_execute('acm', @_) }
sub acm_pca            { shift->_execute('acm-pca', @_) }
sub alexaforbusiness   { shift->_execute('alexaforbusiness', @_) }
sub amp                { shift->_execute('amp', @_) }
sub amplify            { shift->_execute('amplify', @_) }
sub amplifybackend     { shift->_execute('amplifybackend', @_) }
sub amplifyuibuilder   { shift->_execute('amplifyuibuilder', @_) }
sub apigateway         { shift->_execute('apigateway', @_) }
sub apigatewaymanagementapi { shift->_execute('apigatewaymanagementapi', @_) }
sub apigatewayv2       { shift->_execute('apigatewayv2', @_) }
sub appconfig          { shift->_execute('appconfig', @_) }
sub appconfigdata      { shift->_execute('appconfigdata', @_) }
sub appfabric          { shift->_execute('appfabric', @_) }
sub appflow            { shift->_execute('appflow', @_) }
sub appintegrations    { shift->_execute('appintegrations', @_) }
sub application_autoscaling { shift->_execute('application-autoscaling', @_) }
sub application_insights { shift->_execute('application-insights', @_) }
sub applicationcostprofiler { shift->_execute('applicationcostprofiler', @_) }
sub appmesh            { shift->_execute('appmesh', @_) }
sub apprunner          { shift->_execute('apprunner', @_) }
sub appstream          { shift->_execute('appstream', @_) }
sub appsync            { shift->_execute('appsync', @_) }
sub arc_zonal_shift    { shift->_execute('arc-zonal-shift', @_) }
sub athena             { shift->_execute('athena', @_) }
sub auditmanager       { shift->_execute('auditmanager', @_) }
sub autoscaling        { shift->_execute('autoscaling', @_) }
sub autoscaling_plans  { shift->_execute('autoscaling-plans', @_) }
sub backup             { shift->_execute('backup', @_) }
sub backup_gateway     { shift->_execute('backup-gateway', @_) }
sub backupstorage      { shift->_execute('backupstorage', @_) }
sub batch              { shift->_execute('batch', @_) }
sub billingconductor   { shift->_execute('billingconductor', @_) }
sub braket             { shift->_execute('braket', @_) }
sub budgets            { shift->_execute('budgets', @_) }
sub ce                 { shift->_execute('ce', @_) }
sub chime              { shift->_execute('chime', @_) }
sub chime_sdk_identity { shift->_execute('chime-sdk-identity', @_) }
sub chime_sdk_media_pipelines { shift->_execute('chime-sdk-media-pipelines', @_) }
sub chime_sdk_meetings { shift->_execute('chime-sdk-meetings', @_) }
sub chime_sdk_messaging { shift->_execute('chime-sdk-messaging', @_) }
sub chime_sdk_voice    { shift->_execute('chime-sdk-voice', @_) }
sub cleanrooms         { shift->_execute('cleanrooms', @_) }
sub cloud9             { shift->_execute('cloud9', @_) }
sub cloudcontrol       { shift->_execute('cloudcontrol', @_) }
sub clouddirectory     { shift->_execute('clouddirectory', @_) }
sub cloudformation     { shift->_execute('cloudformation', @_) }
sub cloudfront         { shift->_execute('cloudfront', @_) }
sub cloudhsm           { shift->_execute('cloudhsm', @_) }
sub cloudhsmv2         { shift->_execute('cloudhsmv2', @_) }
sub cloudsearch        { shift->_execute('cloudsearch', @_) }
sub cloudsearchdomain  { shift->_execute('cloudsearchdomain', @_) }
sub cloudtrail         { shift->_execute('cloudtrail', @_) }
sub cloudtrail_data    { shift->_execute('cloudtrail-data', @_) }
sub cloudwatch         { shift->_execute('cloudwatch', @_) }
sub codeartifact       { shift->_execute('codeartifact', @_) }
sub codebuild          { shift->_execute('codebuild', @_) }
sub codecatalyst       { shift->_execute('codecatalyst', @_) }
sub codecommit         { shift->_execute('codecommit', @_) }
sub codeguru_reviewer  { shift->_execute('codeguru-reviewer', @_) }
sub codeguru_security  { shift->_execute('codeguru-security', @_) }
sub codeguruprofiler   { shift->_execute('codeguruprofiler', @_) }
sub codepipeline       { shift->_execute('codepipeline', @_) }
sub codestar           { shift->_execute('codestar', @_) }
sub codestar_connections { shift->_execute('codestar-connections', @_) }
sub codestar_notifications { shift->_execute('codestar-notifications', @_) }
sub cognito_identity   { shift->_execute('cognito-identity', @_) }
sub cognito_idp        { shift->_execute('cognito-idp', @_) }
sub cognito_sync       { shift->_execute('cognito-sync', @_) }
sub comprehend         { shift->_execute('comprehend', @_) }
sub comprehendmedical  { shift->_execute('comprehendmedical', @_) }
sub compute_optimizer  { shift->_execute('compute-optimizer', @_) }
sub configservice      { shift->_execute('configservice', @_) }
sub configure          { shift->_execute('configure', @_) }
sub connect            { shift->_execute('connect', @_) }
sub connect_contact_lens { shift->_execute('connect-contact-lens', @_) }
sub connectcampaigns   { shift->_execute('connectcampaigns', @_) }
sub connectcases       { shift->_execute('connectcases', @_) }
sub connectparticipant { shift->_execute('connectparticipant', @_) }
sub controltower       { shift->_execute('controltower', @_) }
sub cur                { shift->_execute('cur', @_) }
sub customer_profiles  { shift->_execute('customer-profiles', @_) }
sub databrew           { shift->_execute('databrew', @_) }
sub dataexchange       { shift->_execute('dataexchange', @_) }
sub datapipeline       { shift->_execute('datapipeline', @_) }
sub datasync           { shift->_execute('datasync', @_) }
sub dax                { shift->_execute('dax', @_) }
sub deploy             { shift->_execute('deploy', @_) }
sub detective          { shift->_execute('detective', @_) }
sub devicefarm         { shift->_execute('devicefarm', @_) }
sub devops_guru        { shift->_execute('devops-guru', @_) }
sub directconnect      { shift->_execute('directconnect', @_) }
sub discovery          { shift->_execute('discovery', @_) }
sub dlm                { shift->_execute('dlm', @_) }
sub dms                { shift->_execute('dms', @_) }
sub docdb              { shift->_execute('docdb', @_) }
sub docdb_elastic      { shift->_execute('docdb-elastic', @_) }
sub drs                { shift->_execute('drs', @_) }
sub ds                 { shift->_execute('ds', @_) }
sub dynamodb           { shift->_execute('dynamodb', @_) }
sub dynamodbstreams    { shift->_execute('dynamodbstreams', @_) }
sub ebs                { shift->_execute('ebs', @_) }
sub ec2                { shift->_execute('ec2', @_) }
sub ec2_instance_connect { shift->_execute('ec2-instance-connect', @_) }
sub ecr                { shift->_execute('ecr', @_) }
sub ecr_public         { shift->_execute('ecr-public', @_) }
sub ecs                { shift->_execute('ecs', @_) }
sub efs                { shift->_execute('efs', @_) }
sub eks                { shift->_execute('eks', @_) }
sub elastic_inference  { shift->_execute('elastic-inference', @_) }
sub elasticache        { shift->_execute('elasticache', @_) }
sub elasticbeanstalk   { shift->_execute('elasticbeanstalk', @_) }
sub elastictranscoder  { shift->_execute('elastictranscoder', @_) }
sub elb                { shift->_execute('elb', @_) }
sub elbv2              { shift->_execute('elbv2', @_) }
sub emr                { shift->_execute('emr', @_) }
sub emr_containers     { shift->_execute('emr-containers', @_) }
sub emr_serverless     { shift->_execute('emr-serverless', @_) }
sub es                 { shift->_execute('es', @_) }
sub events             { shift->_execute('events', @_) }
sub evidently          { shift->_execute('evidently', @_) }
sub finspace           { shift->_execute('finspace', @_) }
sub finspace_data      { shift->_execute('finspace-data', @_) }
sub firehose           { shift->_execute('firehose', @_) }
sub fis                { shift->_execute('fis', @_) }
sub fms                { shift->_execute('fms', @_) }
sub forecast           { shift->_execute('forecast', @_) }
sub forecastquery      { shift->_execute('forecastquery', @_) }
sub frauddetector      { shift->_execute('frauddetector', @_) }
sub fsx                { shift->_execute('fsx', @_) }
sub gamelift           { shift->_execute('gamelift', @_) }
sub gamesparks         { shift->_execute('gamesparks', @_) }
sub glacier            { shift->_execute('glacier', @_) }
sub globalaccelerator  { shift->_execute('globalaccelerator', @_) }
sub glue               { shift->_execute('glue', @_) }
sub grafana            { shift->_execute('grafana', @_) }
sub greengrass         { shift->_execute('greengrass', @_) }
sub greengrassv2       { shift->_execute('greengrassv2', @_) }
sub groundstation      { shift->_execute('groundstation', @_) }
sub guardduty          { shift->_execute('guardduty', @_) }
sub health             { shift->_execute('health', @_) }
sub healthlake         { shift->_execute('healthlake', @_) }
sub history            { shift->_execute('history', @_) }
sub honeycode          { shift->_execute('honeycode', @_) }
sub iam                { shift->_execute('iam', @_) }
sub identitystore      { shift->_execute('identitystore', @_) }
sub imagebuilder       { shift->_execute('imagebuilder', @_) }
sub importexport       { shift->_execute('importexport', @_) }
sub inspector          { shift->_execute('inspector', @_) }
sub inspector2         { shift->_execute('inspector2', @_) }
sub internetmonitor    { shift->_execute('internetmonitor', @_) }
sub iot                { shift->_execute('iot', @_) }
sub iot_data           { shift->_execute('iot-data', @_) }
sub iot_jobs_data      { shift->_execute('iot-jobs-data', @_) }
sub iot_roborunner     { shift->_execute('iot-roborunner', @_) }
sub iot1click_devices  { shift->_execute('iot1click-devices', @_) }
sub iot1click_projects { shift->_execute('iot1click-projects', @_) }
sub iotanalytics       { shift->_execute('iotanalytics', @_) }
sub iotdeviceadvisor   { shift->_execute('iotdeviceadvisor', @_) }
sub iotevents          { shift->_execute('iotevents', @_) }
sub iotevents_data     { shift->_execute('iotevents-data', @_) }
sub iotfleethub        { shift->_execute('iotfleethub', @_) }
sub iotfleetwise       { shift->_execute('iotfleetwise', @_) }
sub iotsecuretunneling { shift->_execute('iotsecuretunneling', @_) }
sub iotsitewise        { shift->_execute('iotsitewise', @_) }
sub iotthingsgraph     { shift->_execute('iotthingsgraph', @_) }
sub iottwinmaker       { shift->_execute('iottwinmaker', @_) }
sub iotwireless        { shift->_execute('iotwireless', @_) }
sub ivs                { shift->_execute('ivs', @_) }
sub ivs_realtime       { shift->_execute('ivs-realtime', @_) }
sub ivschat            { shift->_execute('ivschat', @_) }
sub kafka              { shift->_execute('kafka', @_) }
sub kafkaconnect       { shift->_execute('kafkaconnect', @_) }
sub kendra             { shift->_execute('kendra', @_) }
sub kendra_ranking     { shift->_execute('kendra-ranking', @_) }
sub keyspaces          { shift->_execute('keyspaces', @_) }
sub kinesis            { shift->_execute('kinesis', @_) }
sub kinesis_video_archived_media { shift->_execute('kinesis-video-archived-media', @_) }
sub kinesis_video_media { shift->_execute('kinesis-video-media', @_) }
sub kinesis_video_signaling { shift->_execute('kinesis-video-signaling', @_) }
sub kinesis_video_webrtc_storage { shift->_execute('kinesis-video-webrtc-storage', @_) }
sub kinesisanalytics   { shift->_execute('kinesisanalytics', @_) }
sub kinesisanalyticsv2 { shift->_execute('kinesisanalyticsv2', @_) }
sub kinesisvideo       { shift->_execute('kinesisvideo', @_) }
sub kms                { shift->_execute('kms', @_) }
sub lakeformation      { shift->_execute('lakeformation', @_) }
sub lambda             { shift->_execute('lambda', @_) }
sub lex_models         { shift->_execute('lex-models', @_) }
sub lex_runtime        { shift->_execute('lex-runtime', @_) }
sub lexv2_models       { shift->_execute('lexv2-models', @_) }
sub lexv2_runtime      { shift->_execute('lexv2-runtime', @_) }
sub license_manager    { shift->_execute('license-manager', @_) }
sub license_manager_linux_subscriptions { shift->_execute('license-manager-linux-subscriptions', @_) }
sub license_manager_user_subscriptions { shift->_execute('license-manager-user-subscriptions', @_) }
sub lightsail          { shift->_execute('lightsail', @_) }
sub location           { shift->_execute('location', @_) }
sub logs               { shift->_execute('logs', @_) }
sub lookoutequipment   { shift->_execute('lookoutequipment', @_) }
sub lookoutmetrics     { shift->_execute('lookoutmetrics', @_) }
sub lookoutvision      { shift->_execute('lookoutvision', @_) }
sub m2                 { shift->_execute('m2', @_) }
sub machinelearning    { shift->_execute('machinelearning', @_) }
sub macie              { shift->_execute('macie', @_) }
sub macie2             { shift->_execute('macie2', @_) }
sub managedblockchain  { shift->_execute('managedblockchain', @_) }
sub marketplace_catalog { shift->_execute('marketplace-catalog', @_) }
sub marketplace_entitlement { shift->_execute('marketplace-entitlement', @_) }
sub marketplacecommerceanalytics { shift->_execute('marketplacecommerceanalytics', @_) }
sub mediaconnect       { shift->_execute('mediaconnect', @_) }
sub mediaconvert       { shift->_execute('mediaconvert', @_) }
sub medialive          { shift->_execute('medialive', @_) }
sub mediapackage       { shift->_execute('mediapackage', @_) }
sub mediapackage_vod   { shift->_execute('mediapackage-vod', @_) }
sub mediapackagev2     { shift->_execute('mediapackagev2', @_) }
sub mediastore         { shift->_execute('mediastore', @_) }
sub mediastore_data    { shift->_execute('mediastore-data', @_) }
sub mediatailor        { shift->_execute('mediatailor', @_) }
sub memorydb           { shift->_execute('memorydb', @_) }
sub meteringmarketplace { shift->_execute('meteringmarketplace', @_) }
sub mgh                { shift->_execute('mgh', @_) }
sub mgn                { shift->_execute('mgn', @_) }
sub migration_hub_refactor_spaces { shift->_execute('migration-hub-refactor-spaces', @_) }
sub migrationhub_config { shift->_execute('migrationhub-config', @_) }
sub migrationhuborchestrator { shift->_execute('migrationhuborchestrator', @_) }
sub migrationhubstrategy { shift->_execute('migrationhubstrategy', @_) }
sub mobile             { shift->_execute('mobile', @_) }
sub mq                 { shift->_execute('mq', @_) }
sub mturk              { shift->_execute('mturk', @_) }
sub mwaa               { shift->_execute('mwaa', @_) }
sub neptune            { shift->_execute('neptune', @_) }
sub network_firewall   { shift->_execute('network-firewall', @_) }
sub networkmanager     { shift->_execute('networkmanager', @_) }
sub nimble             { shift->_execute('nimble', @_) }
sub oam                { shift->_execute('oam', @_) }
sub omics              { shift->_execute('omics', @_) }
sub opensearch         { shift->_execute('opensearch', @_) }
sub opensearchserverless { shift->_execute('opensearchserverless', @_) }
sub opsworks           { shift->_execute('opsworks', @_) }
sub opsworks_cm        { shift->_execute('opsworks-cm', @_) }
sub organizations      { shift->_execute('organizations', @_) }
sub osis               { shift->_execute('osis', @_) }
sub outposts           { shift->_execute('outposts', @_) }
sub panorama           { shift->_execute('panorama', @_) }
sub payment_cryptography { shift->_execute('payment-cryptography', @_) }
sub payment_cryptography_data { shift->_execute('payment-cryptography-data', @_) }
sub personalize        { shift->_execute('personalize', @_) }
sub personalize_events { shift->_execute('personalize-events', @_) }
sub personalize_runtime { shift->_execute('personalize-runtime', @_) }
sub pi                 { shift->_execute('pi', @_) }
sub pinpoint           { shift->_execute('pinpoint', @_) }
sub pinpoint_email     { shift->_execute('pinpoint-email', @_) }
sub pinpoint_sms_voice { shift->_execute('pinpoint-sms-voice', @_) }
sub pinpoint_sms_voice_v2 { shift->_execute('pinpoint-sms-voice-v2', @_) }
sub pipes              { shift->_execute('pipes', @_) }
sub polly              { shift->_execute('polly', @_) }
sub pricing            { shift->_execute('pricing', @_) }
sub privatenetworks    { shift->_execute('privatenetworks', @_) }
sub proton             { shift->_execute('proton', @_) }
sub qldb               { shift->_execute('qldb', @_) }
sub qldb_session       { shift->_execute('qldb-session', @_) }
sub quicksight         { shift->_execute('quicksight', @_) }
sub ram                { shift->_execute('ram', @_) }
sub rbin               { shift->_execute('rbin', @_) }
sub rds                { shift->_execute('rds', @_) }
sub rds_data           { shift->_execute('rds-data', @_) }
sub redshift           { shift->_execute('redshift', @_) }
sub redshift_data      { shift->_execute('redshift-data', @_) }
sub redshift_serverless { shift->_execute('redshift-serverless', @_) }
sub rekognition        { shift->_execute('rekognition', @_) }
sub resiliencehub      { shift->_execute('resiliencehub', @_) }
sub resource_explorer_2 { shift->_execute('resource-explorer-2', @_) }
sub resource_groups    { shift->_execute('resource-groups', @_) }
sub resourcegroupstaggingapi { shift->_execute('resourcegroupstaggingapi', @_) }
sub robomaker          { shift->_execute('robomaker', @_) }
sub rolesanywhere      { shift->_execute('rolesanywhere', @_) }
sub route53            { shift->_execute('route53', @_) }
sub route53_recovery_cluster { shift->_execute('route53-recovery-cluster', @_) }
sub route53_recovery_control_config { shift->_execute('route53-recovery-control-config', @_) }
sub route53_recovery_readiness { shift->_execute('route53-recovery-readiness', @_) }
sub route53domains     { shift->_execute('route53domains', @_) }
sub route53resolver    { shift->_execute('route53resolver', @_) }
sub rum                { shift->_execute('rum', @_) }
sub s3                 { shift->_execute('s3', @_) }
sub s3api              { shift->_execute('s3api', @_) }
sub s3control          { shift->_execute('s3control', @_) }
sub s3outposts         { shift->_execute('s3outposts', @_) }
sub sagemaker          { shift->_execute('sagemaker', @_) }
sub sagemaker_a2i_runtime { shift->_execute('sagemaker-a2i-runtime', @_) }
sub sagemaker_edge     { shift->_execute('sagemaker-edge', @_) }
sub sagemaker_featurestore_runtime { shift->_execute('sagemaker-featurestore-runtime', @_) }
sub sagemaker_geospatial { shift->_execute('sagemaker-geospatial', @_) }
sub sagemaker_metrics  { shift->_execute('sagemaker-metrics', @_) }
sub sagemaker_runtime  { shift->_execute('sagemaker-runtime', @_) }
sub savingsplans       { shift->_execute('savingsplans', @_) }
sub scheduler          { shift->_execute('scheduler', @_) }
sub schemas            { shift->_execute('schemas', @_) }
sub sdb                { shift->_execute('sdb', @_) }
sub secretsmanager     { shift->_execute('secretsmanager', @_) }
sub securityhub        { shift->_execute('securityhub', @_) }
sub securitylake       { shift->_execute('securitylake', @_) }
sub serverlessrepo     { shift->_execute('serverlessrepo', @_) }
sub service_quotas     { shift->_execute('service-quotas', @_) }
sub servicecatalog     { shift->_execute('servicecatalog', @_) }
sub servicecatalog_appregistry { shift->_execute('servicecatalog-appregistry', @_) }
sub servicediscovery   { shift->_execute('servicediscovery', @_) }
sub ses                { shift->_execute('ses', @_) }
sub sesv2              { shift->_execute('sesv2', @_) }
sub shield             { shift->_execute('shield', @_) }
sub signer             { shift->_execute('signer', @_) }
sub simspaceweaver     { shift->_execute('simspaceweaver', @_) }
sub sms                { shift->_execute('sms', @_) }
sub snow_device_management { shift->_execute('snow-device-management', @_) }
sub snowball           { shift->_execute('snowball', @_) }
sub sns                { shift->_execute('sns', @_) }
sub sqs                { shift->_execute('sqs', @_) }
sub ssm                { shift->_execute('ssm', @_) }
sub ssm_contacts       { shift->_execute('ssm-contacts', @_) }
sub ssm_incidents      { shift->_execute('ssm-incidents', @_) }
sub ssm_sap            { shift->_execute('ssm-sap', @_) }
sub sso                { shift->_execute('sso', @_) }
sub sso_admin          { shift->_execute('sso-admin', @_) }
sub sso_oidc           { shift->_execute('sso-oidc', @_) }
sub stepfunctions      { shift->_execute('stepfunctions', @_) }
sub storagegateway     { shift->_execute('storagegateway', @_) }
sub sts                { shift->_execute('sts', @_) }
sub support            { shift->_execute('support', @_) }
sub support_app        { shift->_execute('support-app', @_) }

lib/AWS/CLIWrapper.pm  view on Meta::CPAN

=head1 DESCRIPTION

AWS::CLIWrapper is wrapper module for aws-cli (recommend: awscli >= 1.0.0, requires: >= 0.40.0).

AWS::CLIWrapper is a just wrapper module, so you can do everything what you can do with aws-cli.

See note below about making sure AWS credentials are accessible (especially under crond)

=head1 METHODS

=over 4

=item B<new>($param:HashRef)

Constructor of AWS::CLIWrapper. Acceptable AWS CLI params are:

    region       region_name:Str
    profile      profile_name:Str
    endpoint_url endpoint_url:Str

Additionally, the these params can be used to control the wrapper behavior:

    nofork                  Truthy to avoid forking when executing `aws`
    timeout                 `aws` execution timeout
    croak_on_error          Truthy to croak() with the error message when `aws`
                            exits with non-zero code
    catch_error_pattern     Regexp pattern to match for error handling.
    catch_error_retries     Retries for handling errors.
    catch_error_min_delay   Minimal delay before retrying `aws` call
                            when an error was caught.
    catch_error_max_delay   Maximal delay before retrying `aws` call.

See below for more detailed explanation.

=item B<accessanalyzer>($operation:Str, $param:HashRef, %opt:Hash)

=item B<account>($operation:Str, $param:HashRef, %opt:Hash)

=item B<acm>($operation:Str, $param:HashRef, %opt:Hash)

=item B<acm_pca>($operation:Str, $param:HashRef, %opt:Hash)

=item B<alexaforbusiness>($operation:Str, $param:HashRef, %opt:Hash)

=item B<amp>($operation:Str, $param:HashRef, %opt:Hash)

=item B<amplify>($operation:Str, $param:HashRef, %opt:Hash)

=item B<amplifybackend>($operation:Str, $param:HashRef, %opt:Hash)

=item B<amplifyuibuilder>($operation:Str, $param:HashRef, %opt:Hash)

=item B<apigateway>($operation:Str, $param:HashRef, %opt:Hash)

=item B<apigatewaymanagementapi>($operation:Str, $param:HashRef, %opt:Hash)

=item B<apigatewayv2>($operation:Str, $param:HashRef, %opt:Hash)

=item B<appconfig>($operation:Str, $param:HashRef, %opt:Hash)

=item B<appconfigdata>($operation:Str, $param:HashRef, %opt:Hash)

=item B<appfabric>($operation:Str, $param:HashRef, %opt:Hash)

=item B<appflow>($operation:Str, $param:HashRef, %opt:Hash)

=item B<appintegrations>($operation:Str, $param:HashRef, %opt:Hash)

=item B<application_autoscaling>($operation:Str, $param:HashRef, %opt:Hash)

=item B<application_insights>($operation:Str, $param:HashRef, %opt:Hash)

=item B<applicationcostprofiler>($operation:Str, $param:HashRef, %opt:Hash)

=item B<appmesh>($operation:Str, $param:HashRef, %opt:Hash)

=item B<apprunner>($operation:Str, $param:HashRef, %opt:Hash)

=item B<appstream>($operation:Str, $param:HashRef, %opt:Hash)

=item B<appsync>($operation:Str, $param:HashRef, %opt:Hash)

=item B<arc_zonal_shift>($operation:Str, $param:HashRef, %opt:Hash)

=item B<athena>($operation:Str, $param:HashRef, %opt:Hash)

=item B<auditmanager>($operation:Str, $param:HashRef, %opt:Hash)

=item B<autoscaling>($operation:Str, $param:HashRef, %opt:Hash)

=item B<autoscaling_plans>($operation:Str, $param:HashRef, %opt:Hash)

=item B<backup>($operation:Str, $param:HashRef, %opt:Hash)

=item B<backup_gateway>($operation:Str, $param:HashRef, %opt:Hash)

=item B<backupstorage>($operation:Str, $param:HashRef, %opt:Hash)

=item B<batch>($operation:Str, $param:HashRef, %opt:Hash)

=item B<billingconductor>($operation:Str, $param:HashRef, %opt:Hash)

=item B<braket>($operation:Str, $param:HashRef, %opt:Hash)

=item B<budgets>($operation:Str, $param:HashRef, %opt:Hash)

=item B<ce>($operation:Str, $param:HashRef, %opt:Hash)

=item B<chime>($operation:Str, $param:HashRef, %opt:Hash)

=item B<chime_sdk_identity>($operation:Str, $param:HashRef, %opt:Hash)

=item B<chime_sdk_media_pipelines>($operation:Str, $param:HashRef, %opt:Hash)

=item B<chime_sdk_meetings>($operation:Str, $param:HashRef, %opt:Hash)

=item B<chime_sdk_messaging>($operation:Str, $param:HashRef, %opt:Hash)

=item B<chime_sdk_voice>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cleanrooms>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cloud9>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cloudcontrol>($operation:Str, $param:HashRef, %opt:Hash)

=item B<clouddirectory>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cloudformation>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cloudfront>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cloudhsm>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cloudhsmv2>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cloudsearch>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cloudsearchdomain>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cloudtrail>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cloudtrail_data>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cloudwatch>($operation:Str, $param:HashRef, %opt:Hash)

=item B<codeartifact>($operation:Str, $param:HashRef, %opt:Hash)

=item B<codebuild>($operation:Str, $param:HashRef, %opt:Hash)

=item B<codecatalyst>($operation:Str, $param:HashRef, %opt:Hash)

=item B<codecommit>($operation:Str, $param:HashRef, %opt:Hash)

=item B<codeguru_reviewer>($operation:Str, $param:HashRef, %opt:Hash)

=item B<codeguru_security>($operation:Str, $param:HashRef, %opt:Hash)

=item B<codeguruprofiler>($operation:Str, $param:HashRef, %opt:Hash)

=item B<codepipeline>($operation:Str, $param:HashRef, %opt:Hash)

=item B<codestar>($operation:Str, $param:HashRef, %opt:Hash)

=item B<codestar_connections>($operation:Str, $param:HashRef, %opt:Hash)

=item B<codestar_notifications>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cognito_identity>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cognito_idp>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cognito_sync>($operation:Str, $param:HashRef, %opt:Hash)

=item B<comprehend>($operation:Str, $param:HashRef, %opt:Hash)

=item B<comprehendmedical>($operation:Str, $param:HashRef, %opt:Hash)

=item B<compute_optimizer>($operation:Str, $param:HashRef, %opt:Hash)

=item B<configservice>($operation:Str, $param:HashRef, %opt:Hash)

=item B<configure>($operation:Str, $param:HashRef, %opt:Hash)

=item B<connect>($operation:Str, $param:HashRef, %opt:Hash)

=item B<connect_contact_lens>($operation:Str, $param:HashRef, %opt:Hash)

=item B<connectcampaigns>($operation:Str, $param:HashRef, %opt:Hash)

=item B<connectcases>($operation:Str, $param:HashRef, %opt:Hash)

=item B<connectparticipant>($operation:Str, $param:HashRef, %opt:Hash)

=item B<controltower>($operation:Str, $param:HashRef, %opt:Hash)

=item B<cur>($operation:Str, $param:HashRef, %opt:Hash)

=item B<customer_profiles>($operation:Str, $param:HashRef, %opt:Hash)

=item B<databrew>($operation:Str, $param:HashRef, %opt:Hash)

=item B<dataexchange>($operation:Str, $param:HashRef, %opt:Hash)

=item B<datapipeline>($operation:Str, $param:HashRef, %opt:Hash)

=item B<datasync>($operation:Str, $param:HashRef, %opt:Hash)

=item B<dax>($operation:Str, $param:HashRef, %opt:Hash)

=item B<deploy>($operation:Str, $param:HashRef, %opt:Hash)

=item B<detective>($operation:Str, $param:HashRef, %opt:Hash)

=item B<devicefarm>($operation:Str, $param:HashRef, %opt:Hash)

=item B<devops_guru>($operation:Str, $param:HashRef, %opt:Hash)

=item B<directconnect>($operation:Str, $param:HashRef, %opt:Hash)

=item B<discovery>($operation:Str, $param:HashRef, %opt:Hash)

=item B<dlm>($operation:Str, $param:HashRef, %opt:Hash)

=item B<dms>($operation:Str, $param:HashRef, %opt:Hash)

=item B<docdb>($operation:Str, $param:HashRef, %opt:Hash)

=item B<docdb_elastic>($operation:Str, $param:HashRef, %opt:Hash)

=item B<drs>($operation:Str, $param:HashRef, %opt:Hash)

=item B<ds>($operation:Str, $param:HashRef, %opt:Hash)

=item B<dynamodb>($operation:Str, $param:HashRef, %opt:Hash)

=item B<dynamodbstreams>($operation:Str, $param:HashRef, %opt:Hash)

=item B<ebs>($operation:Str, $param:HashRef, %opt:Hash)

=item B<ec2>($operation:Str, $param:HashRef, %opt:Hash)

=item B<ec2_instance_connect>($operation:Str, $param:HashRef, %opt:Hash)

=item B<ecr>($operation:Str, $param:HashRef, %opt:Hash)

=item B<ecr_public>($operation:Str, $param:HashRef, %opt:Hash)

=item B<ecs>($operation:Str, $param:HashRef, %opt:Hash)

=item B<efs>($operation:Str, $param:HashRef, %opt:Hash)

=item B<eks>($operation:Str, $param:HashRef, %opt:Hash)

=item B<elastic_inference>($operation:Str, $param:HashRef, %opt:Hash)

=item B<elasticache>($operation:Str, $param:HashRef, %opt:Hash)

=item B<elasticbeanstalk>($operation:Str, $param:HashRef, %opt:Hash)

=item B<elastictranscoder>($operation:Str, $param:HashRef, %opt:Hash)

=item B<elb>($operation:Str, $param:HashRef, %opt:Hash)

=item B<elbv2>($operation:Str, $param:HashRef, %opt:Hash)

=item B<emr>($operation:Str, $param:HashRef, %opt:Hash)

=item B<emr_containers>($operation:Str, $param:HashRef, %opt:Hash)

=item B<emr_serverless>($operation:Str, $param:HashRef, %opt:Hash)

=item B<es>($operation:Str, $param:HashRef, %opt:Hash)

=item B<events>($operation:Str, $param:HashRef, %opt:Hash)

=item B<evidently>($operation:Str, $param:HashRef, %opt:Hash)

=item B<finspace>($operation:Str, $param:HashRef, %opt:Hash)

=item B<finspace_data>($operation:Str, $param:HashRef, %opt:Hash)

=item B<firehose>($operation:Str, $param:HashRef, %opt:Hash)

=item B<fis>($operation:Str, $param:HashRef, %opt:Hash)

=item B<fms>($operation:Str, $param:HashRef, %opt:Hash)

=item B<forecast>($operation:Str, $param:HashRef, %opt:Hash)

=item B<forecastquery>($operation:Str, $param:HashRef, %opt:Hash)

=item B<frauddetector>($operation:Str, $param:HashRef, %opt:Hash)

=item B<fsx>($operation:Str, $param:HashRef, %opt:Hash)

=item B<gamelift>($operation:Str, $param:HashRef, %opt:Hash)

=item B<gamesparks>($operation:Str, $param:HashRef, %opt:Hash)

=item B<glacier>($operation:Str, $param:HashRef, %opt:Hash)

=item B<globalaccelerator>($operation:Str, $param:HashRef, %opt:Hash)

=item B<glue>($operation:Str, $param:HashRef, %opt:Hash)

=item B<grafana>($operation:Str, $param:HashRef, %opt:Hash)

=item B<greengrass>($operation:Str, $param:HashRef, %opt:Hash)

=item B<greengrassv2>($operation:Str, $param:HashRef, %opt:Hash)

=item B<groundstation>($operation:Str, $param:HashRef, %opt:Hash)

=item B<guardduty>($operation:Str, $param:HashRef, %opt:Hash)

=item B<health>($operation:Str, $param:HashRef, %opt:Hash)

=item B<healthlake>($operation:Str, $param:HashRef, %opt:Hash)

=item B<history>($operation:Str, $param:HashRef, %opt:Hash)

=item B<honeycode>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iam>($operation:Str, $param:HashRef, %opt:Hash)

=item B<identitystore>($operation:Str, $param:HashRef, %opt:Hash)

=item B<imagebuilder>($operation:Str, $param:HashRef, %opt:Hash)

=item B<importexport>($operation:Str, $param:HashRef, %opt:Hash)

=item B<inspector>($operation:Str, $param:HashRef, %opt:Hash)

=item B<inspector2>($operation:Str, $param:HashRef, %opt:Hash)

=item B<internetmonitor>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iot>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iot_data>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iot_jobs_data>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iot_roborunner>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iot1click_devices>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iot1click_projects>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iotanalytics>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iotdeviceadvisor>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iotevents>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iotevents_data>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iotfleethub>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iotfleetwise>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iotsecuretunneling>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iotsitewise>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iotthingsgraph>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iottwinmaker>($operation:Str, $param:HashRef, %opt:Hash)

=item B<iotwireless>($operation:Str, $param:HashRef, %opt:Hash)

=item B<ivs>($operation:Str, $param:HashRef, %opt:Hash)

=item B<ivs_realtime>($operation:Str, $param:HashRef, %opt:Hash)

=item B<ivschat>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kafka>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kafkaconnect>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kendra>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kendra_ranking>($operation:Str, $param:HashRef, %opt:Hash)

=item B<keyspaces>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kinesis>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kinesis_video_archived_media>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kinesis_video_media>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kinesis_video_signaling>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kinesis_video_webrtc_storage>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kinesisanalytics>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kinesisanalyticsv2>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kinesisvideo>($operation:Str, $param:HashRef, %opt:Hash)

=item B<kms>($operation:Str, $param:HashRef, %opt:Hash)

=item B<lakeformation>($operation:Str, $param:HashRef, %opt:Hash)

=item B<lambda>($operation:Str, $param:HashRef, %opt:Hash)

=item B<lex_models>($operation:Str, $param:HashRef, %opt:Hash)

=item B<lex_runtime>($operation:Str, $param:HashRef, %opt:Hash)

=item B<lexv2_models>($operation:Str, $param:HashRef, %opt:Hash)

=item B<lexv2_runtime>($operation:Str, $param:HashRef, %opt:Hash)

=item B<license_manager>($operation:Str, $param:HashRef, %opt:Hash)

=item B<license_manager_linux_subscriptions>($operation:Str, $param:HashRef, %opt:Hash)

=item B<license_manager_user_subscriptions>($operation:Str, $param:HashRef, %opt:Hash)

=item B<lightsail>($operation:Str, $param:HashRef, %opt:Hash)

=item B<location>($operation:Str, $param:HashRef, %opt:Hash)

=item B<logs>($operation:Str, $param:HashRef, %opt:Hash)

=item B<lookoutequipment>($operation:Str, $param:HashRef, %opt:Hash)

=item B<lookoutmetrics>($operation:Str, $param:HashRef, %opt:Hash)

=item B<lookoutvision>($operation:Str, $param:HashRef, %opt:Hash)

=item B<m2>($operation:Str, $param:HashRef, %opt:Hash)

=item B<machinelearning>($operation:Str, $param:HashRef, %opt:Hash)

=item B<macie>($operation:Str, $param:HashRef, %opt:Hash)

=item B<macie2>($operation:Str, $param:HashRef, %opt:Hash)

=item B<managedblockchain>($operation:Str, $param:HashRef, %opt:Hash)

=item B<marketplace_catalog>($operation:Str, $param:HashRef, %opt:Hash)

=item B<marketplace_entitlement>($operation:Str, $param:HashRef, %opt:Hash)

=item B<marketplacecommerceanalytics>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mediaconnect>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mediaconvert>($operation:Str, $param:HashRef, %opt:Hash)

=item B<medialive>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mediapackage>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mediapackage_vod>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mediapackagev2>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mediastore>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mediastore_data>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mediatailor>($operation:Str, $param:HashRef, %opt:Hash)

=item B<memorydb>($operation:Str, $param:HashRef, %opt:Hash)

=item B<meteringmarketplace>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mgh>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mgn>($operation:Str, $param:HashRef, %opt:Hash)

=item B<migration_hub_refactor_spaces>($operation:Str, $param:HashRef, %opt:Hash)

=item B<migrationhub_config>($operation:Str, $param:HashRef, %opt:Hash)

=item B<migrationhuborchestrator>($operation:Str, $param:HashRef, %opt:Hash)

=item B<migrationhubstrategy>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mobile>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mq>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mturk>($operation:Str, $param:HashRef, %opt:Hash)

=item B<mwaa>($operation:Str, $param:HashRef, %opt:Hash)

=item B<neptune>($operation:Str, $param:HashRef, %opt:Hash)

=item B<network_firewall>($operation:Str, $param:HashRef, %opt:Hash)

=item B<networkmanager>($operation:Str, $param:HashRef, %opt:Hash)

=item B<nimble>($operation:Str, $param:HashRef, %opt:Hash)

=item B<oam>($operation:Str, $param:HashRef, %opt:Hash)

=item B<omics>($operation:Str, $param:HashRef, %opt:Hash)

=item B<opensearch>($operation:Str, $param:HashRef, %opt:Hash)

=item B<opensearchserverless>($operation:Str, $param:HashRef, %opt:Hash)

=item B<opsworks>($operation:Str, $param:HashRef, %opt:Hash)

=item B<opsworks_cm>($operation:Str, $param:HashRef, %opt:Hash)

=item B<organizations>($operation:Str, $param:HashRef, %opt:Hash)

=item B<osis>($operation:Str, $param:HashRef, %opt:Hash)

=item B<outposts>($operation:Str, $param:HashRef, %opt:Hash)

=item B<panorama>($operation:Str, $param:HashRef, %opt:Hash)

=item B<payment_cryptography>($operation:Str, $param:HashRef, %opt:Hash)

=item B<payment_cryptography_data>($operation:Str, $param:HashRef, %opt:Hash)

=item B<personalize>($operation:Str, $param:HashRef, %opt:Hash)

=item B<personalize_events>($operation:Str, $param:HashRef, %opt:Hash)

=item B<personalize_runtime>($operation:Str, $param:HashRef, %opt:Hash)

=item B<pi>($operation:Str, $param:HashRef, %opt:Hash)

=item B<pinpoint>($operation:Str, $param:HashRef, %opt:Hash)

=item B<pinpoint_email>($operation:Str, $param:HashRef, %opt:Hash)

=item B<pinpoint_sms_voice>($operation:Str, $param:HashRef, %opt:Hash)

=item B<pinpoint_sms_voice_v2>($operation:Str, $param:HashRef, %opt:Hash)

=item B<pipes>($operation:Str, $param:HashRef, %opt:Hash)

=item B<polly>($operation:Str, $param:HashRef, %opt:Hash)

=item B<pricing>($operation:Str, $param:HashRef, %opt:Hash)

=item B<privatenetworks>($operation:Str, $param:HashRef, %opt:Hash)

=item B<proton>($operation:Str, $param:HashRef, %opt:Hash)

=item B<qldb>($operation:Str, $param:HashRef, %opt:Hash)

=item B<qldb_session>($operation:Str, $param:HashRef, %opt:Hash)

=item B<quicksight>($operation:Str, $param:HashRef, %opt:Hash)

=item B<ram>($operation:Str, $param:HashRef, %opt:Hash)

=item B<rbin>($operation:Str, $param:HashRef, %opt:Hash)

=item B<rds>($operation:Str, $param:HashRef, %opt:Hash)

=item B<rds_data>($operation:Str, $param:HashRef, %opt:Hash)

=item B<redshift>($operation:Str, $param:HashRef, %opt:Hash)

=item B<redshift_data>($operation:Str, $param:HashRef, %opt:Hash)

=item B<redshift_serverless>($operation:Str, $param:HashRef, %opt:Hash)

=item B<rekognition>($operation:Str, $param:HashRef, %opt:Hash)

=item B<resiliencehub>($operation:Str, $param:HashRef, %opt:Hash)

=item B<resource_explorer_2>($operation:Str, $param:HashRef, %opt:Hash)

=item B<resource_groups>($operation:Str, $param:HashRef, %opt:Hash)

=item B<resourcegroupstaggingapi>($operation:Str, $param:HashRef, %opt:Hash)

=item B<robomaker>($operation:Str, $param:HashRef, %opt:Hash)

=item B<rolesanywhere>($operation:Str, $param:HashRef, %opt:Hash)

=item B<route53>($operation:Str, $param:HashRef, %opt:Hash)

=item B<route53_recovery_cluster>($operation:Str, $param:HashRef, %opt:Hash)

=item B<route53_recovery_control_config>($operation:Str, $param:HashRef, %opt:Hash)

=item B<route53_recovery_readiness>($operation:Str, $param:HashRef, %opt:Hash)

=item B<route53domains>($operation:Str, $param:HashRef, %opt:Hash)

=item B<route53resolver>($operation:Str, $param:HashRef, %opt:Hash)

=item B<rum>($operation:Str, $param:HashRef, %opt:Hash)

=item B<s3>($operation:Str, $path:ArrayRef, $param:HashRef, %opt:Hash)

=item B<s3api>($operation:Str, $param:HashRef, %opt:Hash)

=item B<s3control>($operation:Str, $param:HashRef, %opt:Hash)

=item B<s3outposts>($operation:Str, $param:HashRef, %opt:Hash)

=item B<sagemaker>($operation:Str, $param:HashRef, %opt:Hash)

=item B<sagemaker_a2i_runtime>($operation:Str, $param:HashRef, %opt:Hash)

=item B<sagemaker_edge>($operation:Str, $param:HashRef, %opt:Hash)

=item B<sagemaker_featurestore_runtime>($operation:Str, $param:HashRef, %opt:Hash)

=item B<sagemaker_geospatial>($operation:Str, $param:HashRef, %opt:Hash)

=item B<sagemaker_metrics>($operation:Str, $param:HashRef, %opt:Hash)

=item B<sagemaker_runtime>($operation:Str, $param:HashRef, %opt:Hash)

=item B<savingsplans>($operation:Str, $param:HashRef, %opt:Hash)

=item B<scheduler>($operation:Str, $param:HashRef, %opt:Hash)

=item B<schemas>($operation:Str, $param:HashRef, %opt:Hash)

=item B<sdb>($operation:Str, $param:HashRef, %opt:Hash)