@pgarbe/cdk-ecr-sync 0.5.25 → 0.5.28

package/node_modules/aws-sdk/lib/config-base.d.ts

@@ -83,6 +83,7 @@ export interface HTTPOptions {
 export interface Logger {
     write?: (chunk: any, encoding?: string, callback?: () => void) => void
     log?: (...messages: any[]) => void;
+    warn?: (...message: any[]) => void;
 }
 export interface ParamValidation {
     /**

package/node_modules/aws-sdk/lib/config_service_placeholders.d.ts

@@ -300,6 +300,12 @@ export abstract class ConfigurationServicePlaceholders {
   iottwinmaker?: AWS.IoTTwinMaker.Types.ClientConfiguration;
   workspacesweb?: AWS.WorkSpacesWeb.Types.ClientConfiguration;
   amplifyuibuilder?: AWS.AmplifyUIBuilder.Types.ClientConfiguration;
+  keyspaces?: AWS.Keyspaces.Types.ClientConfiguration;
+  billingconductor?: AWS.Billingconductor.Types.ClientConfiguration;
+  gamesparks?: AWS.GameSparks.Types.ClientConfiguration;
+  pinpointsmsvoicev2?: AWS.PinpointSMSVoiceV2.Types.ClientConfiguration;
+  ivschat?: AWS.Ivschat.Types.ClientConfiguration;
+  chimesdkmediapipelines?: AWS.ChimeSDKMediaPipelines.Types.ClientConfiguration;
 }
 export interface ConfigurationServiceApiVersions {
   acm?: AWS.ACM.Types.apiVersion;
@@ -602,4 +608,10 @@ export interface ConfigurationServiceApiVersions {
   iottwinmaker?: AWS.IoTTwinMaker.Types.apiVersion;
   workspacesweb?: AWS.WorkSpacesWeb.Types.apiVersion;
   amplifyuibuilder?: AWS.AmplifyUIBuilder.Types.apiVersion;
+  keyspaces?: AWS.Keyspaces.Types.apiVersion;
+  billingconductor?: AWS.Billingconductor.Types.apiVersion;
+  gamesparks?: AWS.GameSparks.Types.apiVersion;
+  pinpointsmsvoicev2?: AWS.PinpointSMSVoiceV2.Types.apiVersion;
+  ivschat?: AWS.Ivschat.Types.apiVersion;
+  chimesdkmediapipelines?: AWS.ChimeSDKMediaPipelines.Types.apiVersion;
 }

package/node_modules/aws-sdk/lib/core.d.ts

@@ -10,6 +10,7 @@ export {EnvironmentCredentials} from './credentials/environment_credentials';
 export {FileSystemCredentials} from './credentials/file_system_credentials';
 export {SAMLCredentials} from './credentials/saml_credentials';
 export {SharedIniFileCredentials} from './credentials/shared_ini_file_credentials';
+export {SsoCredentials} from './credentials/sso_credentials';
 export {ProcessCredentials} from './credentials/process_credentials';
 export {TemporaryCredentials} from './credentials/temporary_credentials';
 export {ChainableTemporaryCredentials} from './credentials/chainable_temporary_credentials';

package/node_modules/aws-sdk/lib/core.js

@@ -20,7 +20,7 @@ AWS.util.update(AWS, {
   /**
    * @constant
    */
-  VERSION: '2.1060.0',
+  VERSION: '2.1137.0',
 
   /**
    * @api private

package/node_modules/aws-sdk/lib/credentials/credential_provider_chain.js

@@ -152,6 +152,7 @@ AWS.CredentialProviderChain = AWS.util.inherit(AWS.Credentials, {
  * AWS.CredentialProviderChain.defaultProviders = [
  *   function () { return new AWS.EnvironmentCredentials('AWS'); },
  *   function () { return new AWS.EnvironmentCredentials('AMAZON'); },
+ *   function () { return new AWS.SsoCredentials(); },
  *   function () { return new AWS.SharedIniFileCredentials(); },
  *   function () { return new AWS.ECSCredentials(); },
  *   function () { return new AWS.ProcessCredentials(); },

package/node_modules/aws-sdk/lib/credentials/ec2_metadata_credentials.d.ts

@@ -1,21 +1,31 @@
 import {Credentials} from '../credentials';
+import {Logger} from '../config-base';
+
 export class EC2MetadataCredentials extends Credentials {
-		/**
-		 * Creates credentials from the metadata service on an EC2 instance.
-		 * @param {object} options - Override the default (1s) timeout period.
-		 */
-		constructor(options?: EC2MetadataCredentialsOptions);
-	}
-    interface EC2MetadataCredentialsOptions {
-        httpOptions?: {
-            /**
-             * Timeout in milliseconds.
-             */
-            timeout?: number
-            /**
-            * Connection timeout in milliseconds.
-            */
-           connectTimeout?: number
-        }
-        maxRetries?: number
+    /**
+     * Creates credentials from the metadata service on an EC2 instance.
+     * @param {object} options - Override the default (1s) timeout period.
+     */
+    constructor(options?: EC2MetadataCredentialsOptions);
+
+    /**
+     * The original expiration of the current credential. In case of AWS
+     * outage, the EC2 metadata will extend expiration of the existing
+     * credential.
+     */
+    originalExpiration?: Date;
+}
+interface EC2MetadataCredentialsOptions {
+    httpOptions?: {
+        /**
+         * Timeout in milliseconds.
+         */
+        timeout?: number
+        /**
+        * Connection timeout in milliseconds.
+        */
+        connectTimeout?: number
     }
+    maxRetries?: number
+    logger?: Logger
+}

package/node_modules/aws-sdk/lib/credentials/ec2_metadata_credentials.js

@@ -18,15 +18,27 @@ require('../metadata_service');
  * AWS.config.credentials = new AWS.EC2MetadataCredentials({
  *   httpOptions: { timeout: 5000 }, // 5 second timeout
  *   maxRetries: 10, // retry 10 times
- *   retryDelayOptions: { base: 200 } // see AWS.Config for information
+ *   retryDelayOptions: { base: 200 }, // see AWS.Config for information
+ *   logger: console // see AWS.Config for information
  * });
+ * ```
  *
  * If your requests are timing out in connecting to the metadata service, such
  * as when testing on a development machine, you can use the connectTimeout
  * option, specified in milliseconds, which also defaults to 1 second.
- * ```
+ *
+ * If the requests failed or returns expired credentials, it will
+ * extend the expiration of current credential, with a warning message. For more
+ * information, please go to:
+ * https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html
+ *
+ * @!attribute originalExpiration
+ *   @return [Date] The optional original expiration of the current credential.
+ *   In case of AWS outage, the EC2 metadata will extend expiration of the
+ *   existing credential.
  *
  * @see AWS.Config.retryDelayOptions
+ * @see AWS.Config.logger
  *
  * @!macro nobrowser
  */
@@ -44,7 +56,7 @@ AWS.EC2MetadataCredentials = AWS.util.inherit(AWS.Credentials, {
        options.httpOptions);
 
     this.metadataService = new AWS.MetadataService(options);
-    this.metadata = {};
+    this.logger = options.logger || AWS.config && AWS.config.logger;
   },
 
   /**
@@ -62,6 +74,13 @@ AWS.EC2MetadataCredentials = AWS.util.inherit(AWS.Credentials, {
    */
   defaultMaxRetries: 3,
 
+  /**
+   * The original expiration of the current credential. In case of AWS
+   * outage, the EC2 metadata will extend expiration of the existing
+   * credential.
+   */
+  originalExpiration: undefined,
+
   /**
    * Loads the credentials from the instance metadata service
    *
@@ -84,24 +103,62 @@ AWS.EC2MetadataCredentials = AWS.util.inherit(AWS.Credentials, {
   load: function load(callback) {
     var self = this;
     self.metadataService.loadCredentials(function(err, creds) {
-      if (!err) {
-        var currentTime = AWS.util.date.getDate();
-        var expireTime = new Date(creds.Expiration);
-        if (expireTime < currentTime) {
-          err = AWS.util.error(
-            new Error('EC2 Instance Metadata Serivce provided expired credentials'),
-            { code: 'EC2MetadataCredentialsProviderFailure' }
-          );
+      if (err) {
+        if (self.hasLoadedCredentials()) {
+          self.extendExpirationIfExpired();
+          callback();
         } else {
-          self.expired = false;
-          self.metadata = creds;
-          self.accessKeyId = creds.AccessKeyId;
-          self.secretAccessKey = creds.SecretAccessKey;
-          self.sessionToken = creds.Token;
-          self.expireTime = expireTime;
+          callback(err);
         }
+      } else {
+        self.setCredentials(creds);
+        self.extendExpirationIfExpired();
+        callback();
       }
-      callback(err);
     });
+  },
+
+  /**
+   * Whether this credential has been loaded.
+   * @api private
+   */
+  hasLoadedCredentials: function hasLoadedCredentials() {
+    return this.AccessKeyId && this.secretAccessKey;
+  },
+
+  /**
+   * if expired, extend the expiration by 15 minutes base plus a jitter of 5
+   * minutes range.
+   * @api private
+   */
+  extendExpirationIfExpired: function extendExpirationIfExpired() {
+    if (this.needsRefresh()) {
+      this.originalExpiration = this.originalExpiration || this.expireTime;
+      this.expired = false;
+      var nextTimeout = 15 * 60 + Math.floor(Math.random() * 5 * 60);
+      var currentTime = AWS.util.date.getDate().getTime();
+      this.expireTime = new Date(currentTime + nextTimeout * 1000);
+      // TODO: add doc link;
+      this.logger.warn('Attempting credential expiration extension due to a '
+          + 'credential service availability issue. A refresh of these '
+          + 'credentials will be attempted again at ' + this.expireTime
+          + '\nFor more information, please visit: https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html');
+    }
+  },
+
+  /**
+   * Update the credential with new credential responded from EC2 metadata
+   * service.
+   * @api private
+   */
+  setCredentials: function setCredentials(creds) {
+    var currentTime = AWS.util.date.getDate().getTime();
+    var expireTime = new Date(creds.Expiration);
+    this.expired = currentTime >= expireTime ? true : false;
+    this.metadata = creds;
+    this.accessKeyId = creds.AccessKeyId;
+    this.secretAccessKey = creds.SecretAccessKey;
+    this.sessionToken = creds.Token;
+    this.expireTime = expireTime;
   }
 });

package/node_modules/aws-sdk/lib/credentials/sso_credentials.d.ts

@@ -0,0 +1,14 @@
+import {Credentials} from '../credentials';
+import SSO = require('../../clients/sso');
+export class SsoCredentials extends Credentials {
+    /**
+     * Creates a new SsoCredentials object.
+     */
+    constructor(options?: SsoCredentialsOptions);
+}
+
+interface SsoCredentialsOptions {
+    profile?: string;
+    filename?: string;
+    ssoClient?: SSO;
+}

package/node_modules/aws-sdk/lib/credentials/sso_credentials.js

@@ -0,0 +1,179 @@
+var AWS = require('../core');
+var path = require('path');
+var crypto = require('crypto');
+var iniLoader = AWS.util.iniLoader;
+
+/**
+ *  Represents credentials from sso.getRoleCredentials API for
+ * `sso_*` values defined in shared credentials file.
+ *
+ * ## Using SSO credentials
+ *
+ * The credentials file must specify the information below to use sso:
+ *
+ *     [default]
+ *     sso_account_id = 012345678901
+ *     sso_region = us-east-1
+ *     sso_role_name = SampleRole
+ *     sso_start_url = https://d-abc123.awsapps.com/start
+ *
+ * This information will be automatically added to your shared credentials file by running
+ * `aws configure sso`.
+ *
+ * ## Using custom profiles
+ *
+ * The SDK supports loading credentials for separate profiles. This can be done
+ * in two ways:
+ *
+ * 1. Set the `AWS_PROFILE` environment variable in your process prior to
+ *    loading the SDK.
+ * 2. Directly load the AWS.SsoCredentials provider:
+ *
+ * ```javascript
+ * var creds = new AWS.SsoCredentials({profile: 'myprofile'});
+ * AWS.config.credentials = creds;
+ * ```
+ *
+ * @!macro nobrowser
+ */
+AWS.SsoCredentials = AWS.util.inherit(AWS.Credentials, {
+  /**
+   * Creates a new SsoCredentials object.
+   *
+   * @param options [map] a set of options
+   * @option options profile [String] (AWS_PROFILE env var or 'default')
+   *   the name of the profile to load.
+   * @option options filename [String] ('~/.aws/credentials' or defined by
+   *   AWS_SHARED_CREDENTIALS_FILE process env var)
+   *   the filename to use when loading credentials.
+   * @option options callback [Function] (err) Credentials are eagerly loaded
+   *   by the constructor. When the callback is called with no error, the
+   *   credentials have been loaded successfully.
+   */
+  constructor: function SsoCredentials(options) {
+    AWS.Credentials.call(this);
+
+    options = options || {};
+    this.errorCode = 'SsoCredentialsProviderFailure';
+    this.expired = true;
+
+    this.filename = options.filename;
+    this.profile = options.profile || process.env.AWS_PROFILE || AWS.util.defaultProfile;
+    this.service = options.ssoClient;
+    this.get(options.callback || AWS.util.fn.noop);
+  },
+
+  /**
+   * @api private
+   */
+  load: function load(callback) {
+    /**
+     * The time window (15 mins) that SDK will treat the SSO token expires in before the defined expiration date in token.
+     * This is needed because server side may have invalidated the token before the defined expiration date.
+     *
+     * @internal
+     */
+    var EXPIRE_WINDOW_MS = 15 * 60 * 1000;
+    var self = this;
+    try {
+      var profiles = AWS.util.getProfilesFromSharedConfig(iniLoader, this.filename);
+      var profile = profiles[this.profile] || {};
+
+      if (Object.keys(profile).length === 0) {
+        throw AWS.util.error(
+          new Error('Profile ' + this.profile + ' not found'),
+          { code: self.errorCode }
+        );
+      }
+
+      if (!profile.sso_start_url || !profile.sso_account_id || !profile.sso_region || !profile.sso_role_name) {
+        throw AWS.util.error(
+          new Error('Profile ' + this.profile + ' does not have valid SSO credentials. Required parameters "sso_account_id", "sso_region", ' +
+          '"sso_role_name", "sso_start_url". Reference: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html'),
+          { code: self.errorCode }
+        );
+      }
+
+      var hasher = crypto.createHash('sha1');
+      var fileName = hasher.update(profile.sso_start_url).digest('hex') + '.json';
+
+      var cachePath = path.join(
+        iniLoader.getHomeDir(),
+        '.aws',
+        'sso',
+        'cache',
+        fileName
+      );
+      var cacheFile = AWS.util.readFileSync(cachePath);
+      var cacheContent = null;
+      if (cacheFile) {
+        cacheContent = JSON.parse(cacheFile);
+      }
+
+      if (!cacheContent) {
+        throw AWS.util.error(
+          new Error('Cached credentials not found under ' + this.profile + ' profile. Please make sure you log in with aws sso login first'),
+          { code: self.errorCode }
+        );
+      }
+
+      if (!cacheContent.startUrl || !cacheContent.region || !cacheContent.accessToken || !cacheContent.expiresAt) {
+        throw AWS.util.error(
+          new Error('Cached credentials are missing required properties. Try running aws sso login.')
+        );
+      }
+
+      if (new Date(cacheContent.expiresAt).getTime() - Date.now() <= EXPIRE_WINDOW_MS) {
+        throw AWS.util.error(new Error(
+          'The SSO session associated with this profile has expired. To refresh this SSO session run aws sso login with the corresponding profile.'
+        ));
+      }
+
+      if (!self.service || self.service.config.region !== profile.sso_region) {
+        self.service = new AWS.SSO({ region: profile.sso_region });
+      }
+      var request = {
+        accessToken: cacheContent.accessToken,
+        accountId: profile.sso_account_id,
+        roleName: profile.sso_role_name,
+      };
+      self.service.getRoleCredentials(request, function(err, data) {
+        if (err || !data || !data.roleCredentials) {
+          callback(AWS.util.error(
+            err || new Error('Please log in using "aws sso login"'),
+            { code: self.errorCode }
+          ), null);
+        } else if (!data.roleCredentials.accessKeyId || !data.roleCredentials.secretAccessKey || !data.roleCredentials.sessionToken || !data.roleCredentials.expiration) {
+          throw AWS.util.error(new Error(
+            'SSO returns an invalid temporary credential.'
+          ));
+        } else {
+          self.expired = false;
+          self.accessKeyId = data.roleCredentials.accessKeyId;
+          self.secretAccessKey = data.roleCredentials.secretAccessKey;
+          self.sessionToken = data.roleCredentials.sessionToken;
+          self.expireTime = new Date(data.roleCredentials.expiration);
+          callback(null);
+        }
+      });
+    } catch (err) {
+      callback(err);
+    }
+  },
+
+  /**
+   * Loads the credentials from the AWS SSO process
+   *
+   * @callback callback function(err)
+   *   Called after the AWS SSO process has been executed. When this
+   *   callback is called with no error, it means that the credentials
+   *   information has been loaded into the object (as the `accessKeyId`,
+   *   `secretAccessKey`, and `sessionToken` properties).
+   *   @param err [Error] if an error occurred, this value will be filled
+   * @see get
+   */
+  refresh: function refresh(callback) {
+    iniLoader.clearCachedFiles();
+    this.coalesceRefresh(callback || AWS.util.fn.callback);
+  },
+});

package/node_modules/aws-sdk/lib/dynamodb/document_client.d.ts

@@ -1078,6 +1078,10 @@ export namespace DocumentClient {
      */
     NextToken?: PartiQLNextToken;
     ReturnConsumedCapacity?: ReturnConsumedCapacity;
+    /**
+     * The maximum number of items to evaluate (not necessarily the number of matching items). If DynamoDB processes the number of items up to the limit while processing the results, it stops the operation and returns the matching values up to that point, along with a key in LastEvaluatedKey to apply in a subsequent operation so you can pick up where you left off. Also, if the processed dataset size exceeds 1 MB before DynamoDB reaches this limit, it stops the operation and returns the matching values up to the limit, and a key in LastEvaluatedKey to apply in a subsequent operation to continue the operation. 
+     */
+    Limit?: PositiveIntegerObject;
   }
   export interface ExecuteStatementOutput {
     /**
@@ -1089,6 +1093,10 @@ export namespace DocumentClient {
      */
     NextToken?: PartiQLNextToken;
     ConsumedCapacity?: ConsumedCapacity;
+    /**
+     * The primary key of the item where the operation stopped, inclusive of the previous result set. Use this value to start a new operation, excluding this value in the new request. If LastEvaluatedKey is empty, then the "last page" of results has been processed and there is no more data to be retrieved. If LastEvaluatedKey is not empty, it does not necessarily mean that there is more data in the result set. The only way to know when you have reached the end of the result set is when LastEvaluatedKey is empty. 
+     */
+    LastEvaluatedKey?: Key;
   }
   export interface ExecuteTransactionInput {
     /**
@@ -1840,7 +1848,7 @@ export namespace DocumentClient {
   export type PartiQLStatement = string;
   export interface PointInTimeRecoveryDescription {
     /**
-     * The current state of point in time recovery:    ENABLING - Point in time recovery is being enabled.    ENABLED - Point in time recovery is enabled.    DISABLED - Point in time recovery is disabled.  
+     * The current state of point in time recovery:    ENABLED - Point in time recovery is enabled.    DISABLED - Point in time recovery is disabled.  
      */
     PointInTimeRecoveryStatus?: PointInTimeRecoveryStatus;
     /**

package/node_modules/aws-sdk/lib/model/operation.js

@@ -23,7 +23,12 @@ function Operation(name, operation, options) {
       (operation.endpointdiscovery.required ? 'REQUIRED' : 'OPTIONAL') :
     'NULL'
   );
-  property(this, 'httpChecksumRequired', operation.httpChecksumRequired, false);
+
+  // httpChecksum replaces usage of httpChecksumRequired, but some APIs
+  // (s3control) still uses old trait.
+  var httpChecksumRequired = operation.httpChecksumRequired
+    || (operation.httpChecksum && operation.httpChecksum.requestChecksumRequired);
+  property(this, 'httpChecksumRequired', httpChecksumRequired, false);
 
   memoizedProperty(this, 'input', function() {
     if (!operation.input) {

package/node_modules/aws-sdk/lib/node_loader.js

@@ -85,6 +85,7 @@ require('./credentials/environment_credentials');
 require('./credentials/file_system_credentials');
 require('./credentials/shared_ini_file_credentials');
 require('./credentials/process_credentials');
+require('./credentials/sso_credentials');
 
 // Setup default chain providers
 // If this changes, please update documentation for
@@ -93,6 +94,7 @@ require('./credentials/process_credentials');
 AWS.CredentialProviderChain.defaultProviders = [
   function () { return new AWS.EnvironmentCredentials('AWS'); },
   function () { return new AWS.EnvironmentCredentials('AMAZON'); },
+  function () { return new AWS.SsoCredentials(); },
   function () { return new AWS.SharedIniFileCredentials(); },
   function () { return new AWS.ECSCredentials(); },
   function () { return new AWS.ProcessCredentials(); },

package/node_modules/aws-sdk/lib/param_validator.js

@@ -51,8 +51,9 @@ AWS.ParamValidator = AWS.util.inherit({
   },
 
   validateStructure: function validateStructure(shape, params, context) {
-    this.validateType(params, context, ['object'], 'structure');
+    if (shape.isDocument) return true;
 
+    this.validateType(params, context, ['object'], 'structure');
     var paramName;
     for (var i = 0; shape.required && i < shape.required.length; i++) {
       paramName = shape.required[i];

package/node_modules/aws-sdk/lib/region_config_data.json

@@ -24,6 +24,16 @@
       "signingRegion": "cn-northwest-1"
     },
     "us-gov-*/route53": "globalGovCloud",
+    "us-iso-*/route53": {
+      "endpoint": "{service}.c2s.ic.gov",
+      "globalEndpoint": true,
+      "signingRegion": "us-iso-east-1"
+    },
+    "us-isob-*/route53": {
+      "endpoint": "{service}.sc2s.sgov.gov",
+      "globalEndpoint": true,
+      "signingRegion": "us-isob-east-1"
+    },
 
     "*/waf": "globalSSL",
 

package/node_modules/aws-sdk/lib/services/eventbridge.js

@@ -0,0 +1,19 @@
+var AWS = require('../core');
+
+AWS.util.update(AWS.EventBridge.prototype, {
+  /**
+   * @api private
+   */
+  setupRequestListeners: function setupRequestListeners(request) {
+    if (request.operation === 'putEvents') {
+      var params = request.params || {};
+      if (params.EndpointId !== undefined) {
+        throw new AWS.util.error(new Error(), {
+          code: 'InvalidParameter',
+          message: 'EndpointId is not supported in current SDK.\n' +
+            'You should consider switching to V3(https://github.com/aws/aws-sdk-js-v3).'
+        });
+      }
+    }
+  },
+});

package/node_modules/aws-sdk/lib/services/s3.js

@@ -453,7 +453,8 @@ AWS.util.update(AWS.S3.prototype, {
   willComputeChecksums: function willComputeChecksums(req) {
     var rules = req.service.api.operations[req.operation].input.members;
     var body = req.httpRequest.body;
-    var needsContentMD5 = rules.ContentMD5 &&
+    var needsContentMD5 = req.service.config.computeChecksums &&
+      rules.ContentMD5 &&
       !req.params.ContentMD5 &&
       body &&
       (AWS.util.Buffer.isBuffer(req.httpRequest.body) || typeof req.httpRequest.body === 'string');

package/node_modules/aws-sdk/lib/services/s3util.js

@@ -144,9 +144,14 @@ var s3util = {
     var allowFipsEndpoint = options.allowFipsEndpoint || false;
 
     if (!regionFromArn) {
+      var message = 'ARN region is empty';
+      if (req._parsedArn.service === 's3') {
+        message = message + '\nYou may want to use multi-regional ARN. The feature is not supported in current SDK. ' +
+        'You should consider switching to V3(https://github.com/aws/aws-sdk-js-v3).';
+      }
       throw AWS.util.error(new Error(), {
         code: 'InvalidARN',
-        message: 'ARN region is empty'
+        message: message
       });
     }
 

package/node_modules/aws-sdk/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aws-sdk",
   "description": "AWS SDK for JavaScript",
-  "version": "2.1060.0",
+  "version": "2.1137.0",
   "author": {
     "name": "Amazon Web Services",
     "email": "",
@@ -44,7 +44,7 @@
     "buffer": "4.9.2",
     "events": "1.1.1",
     "ieee754": "1.1.13",
-    "jmespath": "0.15.0",
+    "jmespath": "0.16.0",
     "querystring": "0.2.0",
     "sax": "1.2.1",
     "url": "0.10.3",

package/node_modules/aws-sdk/scripts/region-checker/allowlist.js

@@ -16,6 +16,9 @@ var allowlist = {
     '/credentials/shared_ini_file_credentials.js': [
         4,
     ],
+    '/credentials/sso_credentials.js': [
+        15,
+    ],
     '/http.js': [
         5
     ],
@@ -41,13 +44,13 @@ var allowlist = {
         262,
         275,
         281,
-        640,
-        642,
-        761,
-        772,
+        641,
+        643,
+        762,
         773,
         774,
-        779
+        775,
+        780,
     ]
 };