Lesson 35 - Get Compute Auth Token Working

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/AssumeRoleRequest.h

@@ -0,0 +1,411 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/STSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/sts/model/PolicyDescriptorType.h>
+#include <aws/sts/model/Tag.h>
+#include <aws/sts/model/ProvidedContext.h>
+#include <utility>
+
+namespace Aws
+{
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AssumeRoleRequest : public STSRequest
+  {
+  public:
+    AWS_STS_API AssumeRoleRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "AssumeRole"; }
+
+    AWS_STS_API Aws::String SerializePayload() const override;
+
+  protected:
+    AWS_STS_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    ///@{
+    /**
+     * <p>The Amazon Resource Name (ARN) of the role to assume.</p>
+     */
+    inline const Aws::String& GetRoleArn() const{ return m_roleArn; }
+    inline bool RoleArnHasBeenSet() const { return m_roleArnHasBeenSet; }
+    inline void SetRoleArn(const Aws::String& value) { m_roleArnHasBeenSet = true; m_roleArn = value; }
+    inline void SetRoleArn(Aws::String&& value) { m_roleArnHasBeenSet = true; m_roleArn = std::move(value); }
+    inline void SetRoleArn(const char* value) { m_roleArnHasBeenSet = true; m_roleArn.assign(value); }
+    inline AssumeRoleRequest& WithRoleArn(const Aws::String& value) { SetRoleArn(value); return *this;}
+    inline AssumeRoleRequest& WithRoleArn(Aws::String&& value) { SetRoleArn(std::move(value)); return *this;}
+    inline AssumeRoleRequest& WithRoleArn(const char* value) { SetRoleArn(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>An identifier for the assumed role session.</p> <p>Use the role session name
+     * to uniquely identify a session when the same role is assumed by different
+     * principals or for different reasons. In cross-account scenarios, the role
+     * session name is visible to, and can be logged by the account that owns the role.
+     * The role session name is also used in the ARN of the assumed role principal.
+     * This means that subsequent cross-account API requests that use the temporary
+     * security credentials will expose the role session name to the external account
+     * in their CloudTrail logs.</p> <p>The regex used to validate this parameter is a
+     * string of characters consisting of upper- and lower-case alphanumeric characters
+     * with no spaces. You can also include underscores or any of the following
+     * characters: =,.@-</p>
+     */
+    inline const Aws::String& GetRoleSessionName() const{ return m_roleSessionName; }
+    inline bool RoleSessionNameHasBeenSet() const { return m_roleSessionNameHasBeenSet; }
+    inline void SetRoleSessionName(const Aws::String& value) { m_roleSessionNameHasBeenSet = true; m_roleSessionName = value; }
+    inline void SetRoleSessionName(Aws::String&& value) { m_roleSessionNameHasBeenSet = true; m_roleSessionName = std::move(value); }
+    inline void SetRoleSessionName(const char* value) { m_roleSessionNameHasBeenSet = true; m_roleSessionName.assign(value); }
+    inline AssumeRoleRequest& WithRoleSessionName(const Aws::String& value) { SetRoleSessionName(value); return *this;}
+    inline AssumeRoleRequest& WithRoleSessionName(Aws::String&& value) { SetRoleSessionName(std::move(value)); return *this;}
+    inline AssumeRoleRequest& WithRoleSessionName(const char* value) { SetRoleSessionName(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The Amazon Resource Names (ARNs) of the IAM managed policies that you want to
+     * use as managed session policies. The policies must exist in the same account as
+     * the role.</p> <p>This parameter is optional. You can provide up to 10 managed
+     * policy ARNs. However, the plaintext that you use for both inline and managed
+     * session policies can't exceed 2,048 characters. For more information about ARNs,
+     * see <a
+     * href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon
+     * Resource Names (ARNs) and Amazon Web Services Service Namespaces</a> in the
+     * Amazon Web Services General Reference.</p>  <p>An Amazon Web Services
+     * conversion compresses the passed inline session policy, managed policy ARNs, and
+     * session tags into a packed binary format that has a separate limit. Your request
+     * can fail for this limit even if your plaintext meets the other requirements. The
+     * <code>PackedPolicySize</code> response element indicates by percentage how close
+     * the policies and tags for your request are to the upper size limit.</p> 
+     * <p>Passing policies to this operation returns new temporary credentials. The
+     * resulting session's permissions are the intersection of the role's
+     * identity-based policy and the session policies. You can use the role's temporary
+     * credentials in subsequent Amazon Web Services API calls to access resources in
+     * the account that owns the role. You cannot use session policies to grant more
+     * permissions than those allowed by the identity-based policy of the role that is
+     * being assumed. For more information, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">Session
+     * Policies</a> in the <i>IAM User Guide</i>.</p>
+     */
+    inline const Aws::Vector<PolicyDescriptorType>& GetPolicyArns() const{ return m_policyArns; }
+    inline bool PolicyArnsHasBeenSet() const { return m_policyArnsHasBeenSet; }
+    inline void SetPolicyArns(const Aws::Vector<PolicyDescriptorType>& value) { m_policyArnsHasBeenSet = true; m_policyArns = value; }
+    inline void SetPolicyArns(Aws::Vector<PolicyDescriptorType>&& value) { m_policyArnsHasBeenSet = true; m_policyArns = std::move(value); }
+    inline AssumeRoleRequest& WithPolicyArns(const Aws::Vector<PolicyDescriptorType>& value) { SetPolicyArns(value); return *this;}
+    inline AssumeRoleRequest& WithPolicyArns(Aws::Vector<PolicyDescriptorType>&& value) { SetPolicyArns(std::move(value)); return *this;}
+    inline AssumeRoleRequest& AddPolicyArns(const PolicyDescriptorType& value) { m_policyArnsHasBeenSet = true; m_policyArns.push_back(value); return *this; }
+    inline AssumeRoleRequest& AddPolicyArns(PolicyDescriptorType&& value) { m_policyArnsHasBeenSet = true; m_policyArns.push_back(std::move(value)); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>An IAM policy in JSON format that you want to use as an inline session
+     * policy.</p> <p>This parameter is optional. Passing policies to this operation
+     * returns new temporary credentials. The resulting session's permissions are the
+     * intersection of the role's identity-based policy and the session policies. You
+     * can use the role's temporary credentials in subsequent Amazon Web Services API
+     * calls to access resources in the account that owns the role. You cannot use
+     * session policies to grant more permissions than those allowed by the
+     * identity-based policy of the role that is being assumed. For more information,
+     * see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">Session
+     * Policies</a> in the <i>IAM User Guide</i>.</p> <p>The plaintext that you use for
+     * both inline and managed session policies can't exceed 2,048 characters. The JSON
+     * policy characters can be any ASCII character from the space character to the end
+     * of the valid character list (\u0020 through \u00FF). It can also include the tab
+     * (\u0009), linefeed (\u000A), and carriage return (\u000D) characters.</p> 
+     * <p>An Amazon Web Services conversion compresses the passed inline session
+     * policy, managed policy ARNs, and session tags into a packed binary format that
+     * has a separate limit. Your request can fail for this limit even if your
+     * plaintext meets the other requirements. The <code>PackedPolicySize</code>
+     * response element indicates by percentage how close the policies and tags for
+     * your request are to the upper size limit.</p> 
+     */
+    inline const Aws::String& GetPolicy() const{ return m_policy; }
+    inline bool PolicyHasBeenSet() const { return m_policyHasBeenSet; }
+    inline void SetPolicy(const Aws::String& value) { m_policyHasBeenSet = true; m_policy = value; }
+    inline void SetPolicy(Aws::String&& value) { m_policyHasBeenSet = true; m_policy = std::move(value); }
+    inline void SetPolicy(const char* value) { m_policyHasBeenSet = true; m_policy.assign(value); }
+    inline AssumeRoleRequest& WithPolicy(const Aws::String& value) { SetPolicy(value); return *this;}
+    inline AssumeRoleRequest& WithPolicy(Aws::String&& value) { SetPolicy(std::move(value)); return *this;}
+    inline AssumeRoleRequest& WithPolicy(const char* value) { SetPolicy(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The duration, in seconds, of the role session. The value specified can range
+     * from 900 seconds (15 minutes) up to the maximum session duration set for the
+     * role. The maximum session duration setting can have a value from 1 hour to 12
+     * hours. If you specify a value higher than this setting or the administrator
+     * setting (whichever is lower), the operation fails. For example, if you specify a
+     * session duration of 12 hours, but your administrator set the maximum session
+     * duration to 6 hours, your operation fails. </p> <p>Role chaining limits your
+     * Amazon Web Services CLI or Amazon Web Services API role session to a maximum of
+     * one hour. When you use the <code>AssumeRole</code> API operation to assume a
+     * role, you can specify the duration of your role session with the
+     * <code>DurationSeconds</code> parameter. You can specify a parameter value of up
+     * to 43200 seconds (12 hours), depending on the maximum session duration setting
+     * for your role. However, if you assume a role using role chaining and provide a
+     * <code>DurationSeconds</code> parameter value greater than one hour, the
+     * operation fails. To learn how to view the maximum value for your role, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html#id_roles_use_view-role-max-session">View
+     * the Maximum Session Duration Setting for a Role</a> in the <i>IAM User
+     * Guide</i>.</p> <p>By default, the value is set to <code>3600</code> seconds.
+     * </p>  <p>The <code>DurationSeconds</code> parameter is separate from the
+     * duration of a console session that you might request using the returned
+     * credentials. The request to the federation endpoint for a console sign-in token
+     * takes a <code>SessionDuration</code> parameter that specifies the maximum length
+     * of the console session. For more information, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-custom-url.html">Creating
+     * a URL that Enables Federated Users to Access the Amazon Web Services Management
+     * Console</a> in the <i>IAM User Guide</i>.</p> 
+     */
+    inline int GetDurationSeconds() const{ return m_durationSeconds; }
+    inline bool DurationSecondsHasBeenSet() const { return m_durationSecondsHasBeenSet; }
+    inline void SetDurationSeconds(int value) { m_durationSecondsHasBeenSet = true; m_durationSeconds = value; }
+    inline AssumeRoleRequest& WithDurationSeconds(int value) { SetDurationSeconds(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A list of session tags that you want to pass. Each session tag consists of a
+     * key name and an associated value. For more information about session tags, see
+     * <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html">Tagging
+     * Amazon Web Services STS Sessions</a> in the <i>IAM User Guide</i>.</p> <p>This
+     * parameter is optional. You can pass up to 50 session tags. The plaintext session
+     * tag keys can’t exceed 128 characters, and the values can’t exceed 256
+     * characters. For these and additional limits, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-limits.html#reference_iam-limits-entity-length">IAM
+     * and STS Character Limits</a> in the <i>IAM User Guide</i>.</p>  <p>An
+     * Amazon Web Services conversion compresses the passed inline session policy,
+     * managed policy ARNs, and session tags into a packed binary format that has a
+     * separate limit. Your request can fail for this limit even if your plaintext
+     * meets the other requirements. The <code>PackedPolicySize</code> response element
+     * indicates by percentage how close the policies and tags for your request are to
+     * the upper size limit.</p>  <p>You can pass a session tag with the same
+     * key as a tag that is already attached to the role. When you do, session tags
+     * override a role tag with the same key. </p> <p>Tag key–value pairs are not case
+     * sensitive, but case is preserved. This means that you cannot have separate
+     * <code>Department</code> and <code>department</code> tag keys. Assume that the
+     * role has the <code>Department</code>=<code>Marketing</code> tag and you pass the
+     * <code>department</code>=<code>engineering</code> session tag.
+     * <code>Department</code> and <code>department</code> are not saved as separate
+     * tags, and the session tag passed in the request takes precedence over the role
+     * tag.</p> <p>Additionally, if you used temporary credentials to perform this
+     * operation, the new session inherits any transitive session tags from the calling
+     * session. If you pass a session tag with the same key as an inherited tag, the
+     * operation fails. To view the inherited tags for a session, see the CloudTrail
+     * logs. For more information, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_ctlogs">Viewing
+     * Session Tags in CloudTrail</a> in the <i>IAM User Guide</i>.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+    inline AssumeRoleRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+    inline AssumeRoleRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+    inline AssumeRoleRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+    inline AssumeRoleRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>A list of keys for session tags that you want to set as transitive. If you
+     * set a tag key as transitive, the corresponding key and value passes to
+     * subsequent sessions in a role chain. For more information, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_role-chaining">Chaining
+     * Roles with Session Tags</a> in the <i>IAM User Guide</i>.</p> <p>This parameter
+     * is optional. When you set session tags as transitive, the session policy and
+     * session tags packed binary limit is not affected.</p> <p>If you choose not to
+     * specify a transitive tag key, then no tags are passed from this session to any
+     * subsequent sessions.</p>
+     */
+    inline const Aws::Vector<Aws::String>& GetTransitiveTagKeys() const{ return m_transitiveTagKeys; }
+    inline bool TransitiveTagKeysHasBeenSet() const { return m_transitiveTagKeysHasBeenSet; }
+    inline void SetTransitiveTagKeys(const Aws::Vector<Aws::String>& value) { m_transitiveTagKeysHasBeenSet = true; m_transitiveTagKeys = value; }
+    inline void SetTransitiveTagKeys(Aws::Vector<Aws::String>&& value) { m_transitiveTagKeysHasBeenSet = true; m_transitiveTagKeys = std::move(value); }
+    inline AssumeRoleRequest& WithTransitiveTagKeys(const Aws::Vector<Aws::String>& value) { SetTransitiveTagKeys(value); return *this;}
+    inline AssumeRoleRequest& WithTransitiveTagKeys(Aws::Vector<Aws::String>&& value) { SetTransitiveTagKeys(std::move(value)); return *this;}
+    inline AssumeRoleRequest& AddTransitiveTagKeys(const Aws::String& value) { m_transitiveTagKeysHasBeenSet = true; m_transitiveTagKeys.push_back(value); return *this; }
+    inline AssumeRoleRequest& AddTransitiveTagKeys(Aws::String&& value) { m_transitiveTagKeysHasBeenSet = true; m_transitiveTagKeys.push_back(std::move(value)); return *this; }
+    inline AssumeRoleRequest& AddTransitiveTagKeys(const char* value) { m_transitiveTagKeysHasBeenSet = true; m_transitiveTagKeys.push_back(value); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>A unique identifier that might be required when you assume a role in another
+     * account. If the administrator of the account to which the role belongs provided
+     * you with an external ID, then provide that value in the <code>ExternalId</code>
+     * parameter. This value can be any string, such as a passphrase or account number.
+     * A cross-account role is usually set up to trust everyone in an account.
+     * Therefore, the administrator of the trusting account might send an external ID
+     * to the administrator of the trusted account. That way, only someone with the ID
+     * can assume the role, rather than everyone in the account. For more information
+     * about the external ID, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html">How
+     * to Use an External ID When Granting Access to Your Amazon Web Services Resources
+     * to a Third Party</a> in the <i>IAM User Guide</i>.</p> <p>The regex used to
+     * validate this parameter is a string of characters consisting of upper- and
+     * lower-case alphanumeric characters with no spaces. You can also include
+     * underscores or any of the following characters: =,.@:/-</p>
+     */
+    inline const Aws::String& GetExternalId() const{ return m_externalId; }
+    inline bool ExternalIdHasBeenSet() const { return m_externalIdHasBeenSet; }
+    inline void SetExternalId(const Aws::String& value) { m_externalIdHasBeenSet = true; m_externalId = value; }
+    inline void SetExternalId(Aws::String&& value) { m_externalIdHasBeenSet = true; m_externalId = std::move(value); }
+    inline void SetExternalId(const char* value) { m_externalIdHasBeenSet = true; m_externalId.assign(value); }
+    inline AssumeRoleRequest& WithExternalId(const Aws::String& value) { SetExternalId(value); return *this;}
+    inline AssumeRoleRequest& WithExternalId(Aws::String&& value) { SetExternalId(std::move(value)); return *this;}
+    inline AssumeRoleRequest& WithExternalId(const char* value) { SetExternalId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The identification number of the MFA device that is associated with the user
+     * who is making the <code>AssumeRole</code> call. Specify this value if the trust
+     * policy of the role being assumed includes a condition that requires MFA
+     * authentication. The value is either the serial number for a hardware device
+     * (such as <code>GAHT12345678</code>) or an Amazon Resource Name (ARN) for a
+     * virtual device (such as <code>arn:aws:iam::123456789012:mfa/user</code>).</p>
+     * <p>The regex used to validate this parameter is a string of characters
+     * consisting of upper- and lower-case alphanumeric characters with no spaces. You
+     * can also include underscores or any of the following characters: =,.@-</p>
+     */
+    inline const Aws::String& GetSerialNumber() const{ return m_serialNumber; }
+    inline bool SerialNumberHasBeenSet() const { return m_serialNumberHasBeenSet; }
+    inline void SetSerialNumber(const Aws::String& value) { m_serialNumberHasBeenSet = true; m_serialNumber = value; }
+    inline void SetSerialNumber(Aws::String&& value) { m_serialNumberHasBeenSet = true; m_serialNumber = std::move(value); }
+    inline void SetSerialNumber(const char* value) { m_serialNumberHasBeenSet = true; m_serialNumber.assign(value); }
+    inline AssumeRoleRequest& WithSerialNumber(const Aws::String& value) { SetSerialNumber(value); return *this;}
+    inline AssumeRoleRequest& WithSerialNumber(Aws::String&& value) { SetSerialNumber(std::move(value)); return *this;}
+    inline AssumeRoleRequest& WithSerialNumber(const char* value) { SetSerialNumber(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The value provided by the MFA device, if the trust policy of the role being
+     * assumed requires MFA. (In other words, if the policy includes a condition that
+     * tests for MFA). If the role being assumed requires MFA and if the
+     * <code>TokenCode</code> value is missing or expired, the <code>AssumeRole</code>
+     * call returns an "access denied" error.</p> <p>The format for this parameter, as
+     * described by its regex pattern, is a sequence of six numeric digits.</p>
+     */
+    inline const Aws::String& GetTokenCode() const{ return m_tokenCode; }
+    inline bool TokenCodeHasBeenSet() const { return m_tokenCodeHasBeenSet; }
+    inline void SetTokenCode(const Aws::String& value) { m_tokenCodeHasBeenSet = true; m_tokenCode = value; }
+    inline void SetTokenCode(Aws::String&& value) { m_tokenCodeHasBeenSet = true; m_tokenCode = std::move(value); }
+    inline void SetTokenCode(const char* value) { m_tokenCodeHasBeenSet = true; m_tokenCode.assign(value); }
+    inline AssumeRoleRequest& WithTokenCode(const Aws::String& value) { SetTokenCode(value); return *this;}
+    inline AssumeRoleRequest& WithTokenCode(Aws::String&& value) { SetTokenCode(std::move(value)); return *this;}
+    inline AssumeRoleRequest& WithTokenCode(const char* value) { SetTokenCode(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The source identity specified by the principal that is calling the
+     * <code>AssumeRole</code> operation.</p> <p>You can require users to specify a
+     * source identity when they assume a role. You do this by using the
+     * <code>sts:SourceIdentity</code> condition key in a role trust policy. You can
+     * use source identity information in CloudTrail logs to determine who took actions
+     * with a role. You can use the <code>aws:SourceIdentity</code> condition key to
+     * further control access to Amazon Web Services resources based on the value of
+     * source identity. For more information about using source identity, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_monitor.html">Monitor
+     * and control actions taken with assumed roles</a> in the <i>IAM User
+     * Guide</i>.</p> <p>The regex used to validate this parameter is a string of
+     * characters consisting of upper- and lower-case alphanumeric characters with no
+     * spaces. You can also include underscores or any of the following characters:
+     * =,.@-. You cannot use a value that begins with the text <code>aws:</code>. This
+     * prefix is reserved for Amazon Web Services internal use.</p>
+     */
+    inline const Aws::String& GetSourceIdentity() const{ return m_sourceIdentity; }
+    inline bool SourceIdentityHasBeenSet() const { return m_sourceIdentityHasBeenSet; }
+    inline void SetSourceIdentity(const Aws::String& value) { m_sourceIdentityHasBeenSet = true; m_sourceIdentity = value; }
+    inline void SetSourceIdentity(Aws::String&& value) { m_sourceIdentityHasBeenSet = true; m_sourceIdentity = std::move(value); }
+    inline void SetSourceIdentity(const char* value) { m_sourceIdentityHasBeenSet = true; m_sourceIdentity.assign(value); }
+    inline AssumeRoleRequest& WithSourceIdentity(const Aws::String& value) { SetSourceIdentity(value); return *this;}
+    inline AssumeRoleRequest& WithSourceIdentity(Aws::String&& value) { SetSourceIdentity(std::move(value)); return *this;}
+    inline AssumeRoleRequest& WithSourceIdentity(const char* value) { SetSourceIdentity(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A list of previously acquired trusted context assertions in the format of a
+     * JSON array. The trusted context assertion is signed and encrypted by Amazon Web
+     * Services STS.</p> <p>The following is an example of a
+     * <code>ProvidedContext</code> value that includes a single trusted context
+     * assertion and the ARN of the context provider from which the trusted context
+     * assertion was generated.</p> <p>
+     * <code>[{"ProviderArn":"arn:aws:iam::aws:contextProvider/IdentityCenter","ContextAssertion":"trusted-context-assertion"}]</code>
+     * </p>
+     */
+    inline const Aws::Vector<ProvidedContext>& GetProvidedContexts() const{ return m_providedContexts; }
+    inline bool ProvidedContextsHasBeenSet() const { return m_providedContextsHasBeenSet; }
+    inline void SetProvidedContexts(const Aws::Vector<ProvidedContext>& value) { m_providedContextsHasBeenSet = true; m_providedContexts = value; }
+    inline void SetProvidedContexts(Aws::Vector<ProvidedContext>&& value) { m_providedContextsHasBeenSet = true; m_providedContexts = std::move(value); }
+    inline AssumeRoleRequest& WithProvidedContexts(const Aws::Vector<ProvidedContext>& value) { SetProvidedContexts(value); return *this;}
+    inline AssumeRoleRequest& WithProvidedContexts(Aws::Vector<ProvidedContext>&& value) { SetProvidedContexts(std::move(value)); return *this;}
+    inline AssumeRoleRequest& AddProvidedContexts(const ProvidedContext& value) { m_providedContextsHasBeenSet = true; m_providedContexts.push_back(value); return *this; }
+    inline AssumeRoleRequest& AddProvidedContexts(ProvidedContext&& value) { m_providedContextsHasBeenSet = true; m_providedContexts.push_back(std::move(value)); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_roleArn;
+    bool m_roleArnHasBeenSet = false;
+
+    Aws::String m_roleSessionName;
+    bool m_roleSessionNameHasBeenSet = false;
+
+    Aws::Vector<PolicyDescriptorType> m_policyArns;
+    bool m_policyArnsHasBeenSet = false;
+
+    Aws::String m_policy;
+    bool m_policyHasBeenSet = false;
+
+    int m_durationSeconds;
+    bool m_durationSecondsHasBeenSet = false;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet = false;
+
+    Aws::Vector<Aws::String> m_transitiveTagKeys;
+    bool m_transitiveTagKeysHasBeenSet = false;
+
+    Aws::String m_externalId;
+    bool m_externalIdHasBeenSet = false;
+
+    Aws::String m_serialNumber;
+    bool m_serialNumberHasBeenSet = false;
+
+    Aws::String m_tokenCode;
+    bool m_tokenCodeHasBeenSet = false;
+
+    Aws::String m_sourceIdentity;
+    bool m_sourceIdentityHasBeenSet = false;
+
+    Aws::Vector<ProvidedContext> m_providedContexts;
+    bool m_providedContextsHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/AssumeRoleResult.h

@@ -0,0 +1,136 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/model/Credentials.h>
+#include <aws/sts/model/AssumedRoleUser.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/sts/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+  /**
+   * <p>Contains the response to a successful <a>AssumeRole</a> request, including
+   * temporary Amazon Web Services credentials that can be used to make Amazon Web
+   * Services requests. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleResponse">AWS
+   * API Reference</a></p>
+   */
+  class AssumeRoleResult
+  {
+  public:
+    AWS_STS_API AssumeRoleResult();
+    AWS_STS_API AssumeRoleResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_STS_API AssumeRoleResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>The temporary security credentials, which include an access key ID, a secret
+     * access key, and a security (or session) token.</p>  <p>The size of the
+     * security token that STS API operations return is not fixed. We strongly
+     * recommend that you make no assumptions about the maximum size.</p> 
+     */
+    inline const Credentials& GetCredentials() const{ return m_credentials; }
+    inline void SetCredentials(const Credentials& value) { m_credentials = value; }
+    inline void SetCredentials(Credentials&& value) { m_credentials = std::move(value); }
+    inline AssumeRoleResult& WithCredentials(const Credentials& value) { SetCredentials(value); return *this;}
+    inline AssumeRoleResult& WithCredentials(Credentials&& value) { SetCredentials(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The Amazon Resource Name (ARN) and the assumed role ID, which are identifiers
+     * that you can use to refer to the resulting temporary security credentials. For
+     * example, you can reference these credentials as a principal in a resource-based
+     * policy by using the ARN or assumed role ID. The ARN and ID include the
+     * <code>RoleSessionName</code> that you specified when you called
+     * <code>AssumeRole</code>. </p>
+     */
+    inline const AssumedRoleUser& GetAssumedRoleUser() const{ return m_assumedRoleUser; }
+    inline void SetAssumedRoleUser(const AssumedRoleUser& value) { m_assumedRoleUser = value; }
+    inline void SetAssumedRoleUser(AssumedRoleUser&& value) { m_assumedRoleUser = std::move(value); }
+    inline AssumeRoleResult& WithAssumedRoleUser(const AssumedRoleUser& value) { SetAssumedRoleUser(value); return *this;}
+    inline AssumeRoleResult& WithAssumedRoleUser(AssumedRoleUser&& value) { SetAssumedRoleUser(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A percentage value that indicates the packed size of the session policies and
+     * session tags combined passed in the request. The request fails if the packed
+     * size is greater than 100 percent, which means the policies and tags exceeded the
+     * allowed space.</p>
+     */
+    inline int GetPackedPolicySize() const{ return m_packedPolicySize; }
+    inline void SetPackedPolicySize(int value) { m_packedPolicySize = value; }
+    inline AssumeRoleResult& WithPackedPolicySize(int value) { SetPackedPolicySize(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The source identity specified by the principal that is calling the
+     * <code>AssumeRole</code> operation.</p> <p>You can require users to specify a
+     * source identity when they assume a role. You do this by using the
+     * <code>sts:SourceIdentity</code> condition key in a role trust policy. You can
+     * use source identity information in CloudTrail logs to determine who took actions
+     * with a role. You can use the <code>aws:SourceIdentity</code> condition key to
+     * further control access to Amazon Web Services resources based on the value of
+     * source identity. For more information about using source identity, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_monitor.html">Monitor
+     * and control actions taken with assumed roles</a> in the <i>IAM User
+     * Guide</i>.</p> <p>The regex used to validate this parameter is a string of
+     * characters consisting of upper- and lower-case alphanumeric characters with no
+     * spaces. You can also include underscores or any of the following characters:
+     * =,.@-</p>
+     */
+    inline const Aws::String& GetSourceIdentity() const{ return m_sourceIdentity; }
+    inline void SetSourceIdentity(const Aws::String& value) { m_sourceIdentity = value; }
+    inline void SetSourceIdentity(Aws::String&& value) { m_sourceIdentity = std::move(value); }
+    inline void SetSourceIdentity(const char* value) { m_sourceIdentity.assign(value); }
+    inline AssumeRoleResult& WithSourceIdentity(const Aws::String& value) { SetSourceIdentity(value); return *this;}
+    inline AssumeRoleResult& WithSourceIdentity(Aws::String&& value) { SetSourceIdentity(std::move(value)); return *this;}
+    inline AssumeRoleResult& WithSourceIdentity(const char* value) { SetSourceIdentity(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+    inline AssumeRoleResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+    inline AssumeRoleResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Credentials m_credentials;
+
+    AssumedRoleUser m_assumedRoleUser;
+
+    int m_packedPolicySize;
+
+    Aws::String m_sourceIdentity;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/AssumeRoleWithSAMLRequest.h

@@ -0,0 +1,209 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/STSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/sts/model/PolicyDescriptorType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AssumeRoleWithSAMLRequest : public STSRequest
+  {
+  public:
+    AWS_STS_API AssumeRoleWithSAMLRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "AssumeRoleWithSAML"; }
+
+    AWS_STS_API Aws::String SerializePayload() const override;
+
+  protected:
+    AWS_STS_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    ///@{
+    /**
+     * <p>The Amazon Resource Name (ARN) of the role that the caller is assuming.</p>
+     */
+    inline const Aws::String& GetRoleArn() const{ return m_roleArn; }
+    inline bool RoleArnHasBeenSet() const { return m_roleArnHasBeenSet; }
+    inline void SetRoleArn(const Aws::String& value) { m_roleArnHasBeenSet = true; m_roleArn = value; }
+    inline void SetRoleArn(Aws::String&& value) { m_roleArnHasBeenSet = true; m_roleArn = std::move(value); }
+    inline void SetRoleArn(const char* value) { m_roleArnHasBeenSet = true; m_roleArn.assign(value); }
+    inline AssumeRoleWithSAMLRequest& WithRoleArn(const Aws::String& value) { SetRoleArn(value); return *this;}
+    inline AssumeRoleWithSAMLRequest& WithRoleArn(Aws::String&& value) { SetRoleArn(std::move(value)); return *this;}
+    inline AssumeRoleWithSAMLRequest& WithRoleArn(const char* value) { SetRoleArn(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The Amazon Resource Name (ARN) of the SAML provider in IAM that describes the
+     * IdP.</p>
+     */
+    inline const Aws::String& GetPrincipalArn() const{ return m_principalArn; }
+    inline bool PrincipalArnHasBeenSet() const { return m_principalArnHasBeenSet; }
+    inline void SetPrincipalArn(const Aws::String& value) { m_principalArnHasBeenSet = true; m_principalArn = value; }
+    inline void SetPrincipalArn(Aws::String&& value) { m_principalArnHasBeenSet = true; m_principalArn = std::move(value); }
+    inline void SetPrincipalArn(const char* value) { m_principalArnHasBeenSet = true; m_principalArn.assign(value); }
+    inline AssumeRoleWithSAMLRequest& WithPrincipalArn(const Aws::String& value) { SetPrincipalArn(value); return *this;}
+    inline AssumeRoleWithSAMLRequest& WithPrincipalArn(Aws::String&& value) { SetPrincipalArn(std::move(value)); return *this;}
+    inline AssumeRoleWithSAMLRequest& WithPrincipalArn(const char* value) { SetPrincipalArn(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The base64 encoded SAML authentication response provided by the IdP.</p>
+     * <p>For more information, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/create-role-saml-IdP-tasks.html">Configuring
+     * a Relying Party and Adding Claims</a> in the <i>IAM User Guide</i>. </p>
+     */
+    inline const Aws::String& GetSAMLAssertion() const{ return m_sAMLAssertion; }
+    inline bool SAMLAssertionHasBeenSet() const { return m_sAMLAssertionHasBeenSet; }
+    inline void SetSAMLAssertion(const Aws::String& value) { m_sAMLAssertionHasBeenSet = true; m_sAMLAssertion = value; }
+    inline void SetSAMLAssertion(Aws::String&& value) { m_sAMLAssertionHasBeenSet = true; m_sAMLAssertion = std::move(value); }
+    inline void SetSAMLAssertion(const char* value) { m_sAMLAssertionHasBeenSet = true; m_sAMLAssertion.assign(value); }
+    inline AssumeRoleWithSAMLRequest& WithSAMLAssertion(const Aws::String& value) { SetSAMLAssertion(value); return *this;}
+    inline AssumeRoleWithSAMLRequest& WithSAMLAssertion(Aws::String&& value) { SetSAMLAssertion(std::move(value)); return *this;}
+    inline AssumeRoleWithSAMLRequest& WithSAMLAssertion(const char* value) { SetSAMLAssertion(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The Amazon Resource Names (ARNs) of the IAM managed policies that you want to
+     * use as managed session policies. The policies must exist in the same account as
+     * the role.</p> <p>This parameter is optional. You can provide up to 10 managed
+     * policy ARNs. However, the plaintext that you use for both inline and managed
+     * session policies can't exceed 2,048 characters. For more information about ARNs,
+     * see <a
+     * href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon
+     * Resource Names (ARNs) and Amazon Web Services Service Namespaces</a> in the
+     * Amazon Web Services General Reference.</p>  <p>An Amazon Web Services
+     * conversion compresses the passed inline session policy, managed policy ARNs, and
+     * session tags into a packed binary format that has a separate limit. Your request
+     * can fail for this limit even if your plaintext meets the other requirements. The
+     * <code>PackedPolicySize</code> response element indicates by percentage how close
+     * the policies and tags for your request are to the upper size limit.</p> 
+     * <p>Passing policies to this operation returns new temporary credentials. The
+     * resulting session's permissions are the intersection of the role's
+     * identity-based policy and the session policies. You can use the role's temporary
+     * credentials in subsequent Amazon Web Services API calls to access resources in
+     * the account that owns the role. You cannot use session policies to grant more
+     * permissions than those allowed by the identity-based policy of the role that is
+     * being assumed. For more information, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">Session
+     * Policies</a> in the <i>IAM User Guide</i>.</p>
+     */
+    inline const Aws::Vector<PolicyDescriptorType>& GetPolicyArns() const{ return m_policyArns; }
+    inline bool PolicyArnsHasBeenSet() const { return m_policyArnsHasBeenSet; }
+    inline void SetPolicyArns(const Aws::Vector<PolicyDescriptorType>& value) { m_policyArnsHasBeenSet = true; m_policyArns = value; }
+    inline void SetPolicyArns(Aws::Vector<PolicyDescriptorType>&& value) { m_policyArnsHasBeenSet = true; m_policyArns = std::move(value); }
+    inline AssumeRoleWithSAMLRequest& WithPolicyArns(const Aws::Vector<PolicyDescriptorType>& value) { SetPolicyArns(value); return *this;}
+    inline AssumeRoleWithSAMLRequest& WithPolicyArns(Aws::Vector<PolicyDescriptorType>&& value) { SetPolicyArns(std::move(value)); return *this;}
+    inline AssumeRoleWithSAMLRequest& AddPolicyArns(const PolicyDescriptorType& value) { m_policyArnsHasBeenSet = true; m_policyArns.push_back(value); return *this; }
+    inline AssumeRoleWithSAMLRequest& AddPolicyArns(PolicyDescriptorType&& value) { m_policyArnsHasBeenSet = true; m_policyArns.push_back(std::move(value)); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>An IAM policy in JSON format that you want to use as an inline session
+     * policy.</p> <p>This parameter is optional. Passing policies to this operation
+     * returns new temporary credentials. The resulting session's permissions are the
+     * intersection of the role's identity-based policy and the session policies. You
+     * can use the role's temporary credentials in subsequent Amazon Web Services API
+     * calls to access resources in the account that owns the role. You cannot use
+     * session policies to grant more permissions than those allowed by the
+     * identity-based policy of the role that is being assumed. For more information,
+     * see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">Session
+     * Policies</a> in the <i>IAM User Guide</i>. </p> <p>The plaintext that you use
+     * for both inline and managed session policies can't exceed 2,048 characters. The
+     * JSON policy characters can be any ASCII character from the space character to
+     * the end of the valid character list (\u0020 through \u00FF). It can also include
+     * the tab (\u0009), linefeed (\u000A), and carriage return (\u000D)
+     * characters.</p>  <p>An Amazon Web Services conversion compresses the
+     * passed inline session policy, managed policy ARNs, and session tags into a
+     * packed binary format that has a separate limit. Your request can fail for this
+     * limit even if your plaintext meets the other requirements. The
+     * <code>PackedPolicySize</code> response element indicates by percentage how close
+     * the policies and tags for your request are to the upper size limit.</p> 
+     */
+    inline const Aws::String& GetPolicy() const{ return m_policy; }
+    inline bool PolicyHasBeenSet() const { return m_policyHasBeenSet; }
+    inline void SetPolicy(const Aws::String& value) { m_policyHasBeenSet = true; m_policy = value; }
+    inline void SetPolicy(Aws::String&& value) { m_policyHasBeenSet = true; m_policy = std::move(value); }
+    inline void SetPolicy(const char* value) { m_policyHasBeenSet = true; m_policy.assign(value); }
+    inline AssumeRoleWithSAMLRequest& WithPolicy(const Aws::String& value) { SetPolicy(value); return *this;}
+    inline AssumeRoleWithSAMLRequest& WithPolicy(Aws::String&& value) { SetPolicy(std::move(value)); return *this;}
+    inline AssumeRoleWithSAMLRequest& WithPolicy(const char* value) { SetPolicy(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The duration, in seconds, of the role session. Your role session lasts for
+     * the duration that you specify for the <code>DurationSeconds</code> parameter, or
+     * until the time specified in the SAML authentication response's
+     * <code>SessionNotOnOrAfter</code> value, whichever is shorter. You can provide a
+     * <code>DurationSeconds</code> value from 900 seconds (15 minutes) up to the
+     * maximum session duration setting for the role. This setting can have a value
+     * from 1 hour to 12 hours. If you specify a value higher than this setting, the
+     * operation fails. For example, if you specify a session duration of 12 hours, but
+     * your administrator set the maximum session duration to 6 hours, your operation
+     * fails. To learn how to view the maximum value for your role, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html#id_roles_use_view-role-max-session">View
+     * the Maximum Session Duration Setting for a Role</a> in the <i>IAM User
+     * Guide</i>.</p> <p>By default, the value is set to <code>3600</code> seconds.
+     * </p>  <p>The <code>DurationSeconds</code> parameter is separate from the
+     * duration of a console session that you might request using the returned
+     * credentials. The request to the federation endpoint for a console sign-in token
+     * takes a <code>SessionDuration</code> parameter that specifies the maximum length
+     * of the console session. For more information, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-custom-url.html">Creating
+     * a URL that Enables Federated Users to Access the Amazon Web Services Management
+     * Console</a> in the <i>IAM User Guide</i>.</p> 
+     */
+    inline int GetDurationSeconds() const{ return m_durationSeconds; }
+    inline bool DurationSecondsHasBeenSet() const { return m_durationSecondsHasBeenSet; }
+    inline void SetDurationSeconds(int value) { m_durationSecondsHasBeenSet = true; m_durationSeconds = value; }
+    inline AssumeRoleWithSAMLRequest& WithDurationSeconds(int value) { SetDurationSeconds(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_roleArn;
+    bool m_roleArnHasBeenSet = false;
+
+    Aws::String m_principalArn;
+    bool m_principalArnHasBeenSet = false;
+
+    Aws::String m_sAMLAssertion;
+    bool m_sAMLAssertionHasBeenSet = false;
+
+    Aws::Vector<PolicyDescriptorType> m_policyArns;
+    bool m_policyArnsHasBeenSet = false;
+
+    Aws::String m_policy;
+    bool m_policyHasBeenSet = false;
+
+    int m_durationSeconds;
+    bool m_durationSecondsHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/AssumeRoleWithSAMLResult.h

@@ -0,0 +1,228 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/model/Credentials.h>
+#include <aws/sts/model/AssumedRoleUser.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/sts/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+  /**
+   * <p>Contains the response to a successful <a>AssumeRoleWithSAML</a> request,
+   * including temporary Amazon Web Services credentials that can be used to make
+   * Amazon Web Services requests. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithSAMLResponse">AWS
+   * API Reference</a></p>
+   */
+  class AssumeRoleWithSAMLResult
+  {
+  public:
+    AWS_STS_API AssumeRoleWithSAMLResult();
+    AWS_STS_API AssumeRoleWithSAMLResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_STS_API AssumeRoleWithSAMLResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>The temporary security credentials, which include an access key ID, a secret
+     * access key, and a security (or session) token.</p>  <p>The size of the
+     * security token that STS API operations return is not fixed. We strongly
+     * recommend that you make no assumptions about the maximum size.</p> 
+     */
+    inline const Credentials& GetCredentials() const{ return m_credentials; }
+    inline void SetCredentials(const Credentials& value) { m_credentials = value; }
+    inline void SetCredentials(Credentials&& value) { m_credentials = std::move(value); }
+    inline AssumeRoleWithSAMLResult& WithCredentials(const Credentials& value) { SetCredentials(value); return *this;}
+    inline AssumeRoleWithSAMLResult& WithCredentials(Credentials&& value) { SetCredentials(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The identifiers for the temporary security credentials that the operation
+     * returns.</p>
+     */
+    inline const AssumedRoleUser& GetAssumedRoleUser() const{ return m_assumedRoleUser; }
+    inline void SetAssumedRoleUser(const AssumedRoleUser& value) { m_assumedRoleUser = value; }
+    inline void SetAssumedRoleUser(AssumedRoleUser&& value) { m_assumedRoleUser = std::move(value); }
+    inline AssumeRoleWithSAMLResult& WithAssumedRoleUser(const AssumedRoleUser& value) { SetAssumedRoleUser(value); return *this;}
+    inline AssumeRoleWithSAMLResult& WithAssumedRoleUser(AssumedRoleUser&& value) { SetAssumedRoleUser(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A percentage value that indicates the packed size of the session policies and
+     * session tags combined passed in the request. The request fails if the packed
+     * size is greater than 100 percent, which means the policies and tags exceeded the
+     * allowed space.</p>
+     */
+    inline int GetPackedPolicySize() const{ return m_packedPolicySize; }
+    inline void SetPackedPolicySize(int value) { m_packedPolicySize = value; }
+    inline AssumeRoleWithSAMLResult& WithPackedPolicySize(int value) { SetPackedPolicySize(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The value of the <code>NameID</code> element in the <code>Subject</code>
+     * element of the SAML assertion.</p>
+     */
+    inline const Aws::String& GetSubject() const{ return m_subject; }
+    inline void SetSubject(const Aws::String& value) { m_subject = value; }
+    inline void SetSubject(Aws::String&& value) { m_subject = std::move(value); }
+    inline void SetSubject(const char* value) { m_subject.assign(value); }
+    inline AssumeRoleWithSAMLResult& WithSubject(const Aws::String& value) { SetSubject(value); return *this;}
+    inline AssumeRoleWithSAMLResult& WithSubject(Aws::String&& value) { SetSubject(std::move(value)); return *this;}
+    inline AssumeRoleWithSAMLResult& WithSubject(const char* value) { SetSubject(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p> The format of the name ID, as defined by the <code>Format</code> attribute
+     * in the <code>NameID</code> element of the SAML assertion. Typical examples of
+     * the format are <code>transient</code> or <code>persistent</code>. </p> <p> If
+     * the format includes the prefix
+     * <code>urn:oasis:names:tc:SAML:2.0:nameid-format</code>, that prefix is removed.
+     * For example, <code>urn:oasis:names:tc:SAML:2.0:nameid-format:transient</code> is
+     * returned as <code>transient</code>. If the format includes any other prefix, the
+     * format is returned with no modifications.</p>
+     */
+    inline const Aws::String& GetSubjectType() const{ return m_subjectType; }
+    inline void SetSubjectType(const Aws::String& value) { m_subjectType = value; }
+    inline void SetSubjectType(Aws::String&& value) { m_subjectType = std::move(value); }
+    inline void SetSubjectType(const char* value) { m_subjectType.assign(value); }
+    inline AssumeRoleWithSAMLResult& WithSubjectType(const Aws::String& value) { SetSubjectType(value); return *this;}
+    inline AssumeRoleWithSAMLResult& WithSubjectType(Aws::String&& value) { SetSubjectType(std::move(value)); return *this;}
+    inline AssumeRoleWithSAMLResult& WithSubjectType(const char* value) { SetSubjectType(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The value of the <code>Issuer</code> element of the SAML assertion.</p>
+     */
+    inline const Aws::String& GetIssuer() const{ return m_issuer; }
+    inline void SetIssuer(const Aws::String& value) { m_issuer = value; }
+    inline void SetIssuer(Aws::String&& value) { m_issuer = std::move(value); }
+    inline void SetIssuer(const char* value) { m_issuer.assign(value); }
+    inline AssumeRoleWithSAMLResult& WithIssuer(const Aws::String& value) { SetIssuer(value); return *this;}
+    inline AssumeRoleWithSAMLResult& WithIssuer(Aws::String&& value) { SetIssuer(std::move(value)); return *this;}
+    inline AssumeRoleWithSAMLResult& WithIssuer(const char* value) { SetIssuer(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p> The value of the <code>Recipient</code> attribute of the
+     * <code>SubjectConfirmationData</code> element of the SAML assertion. </p>
+     */
+    inline const Aws::String& GetAudience() const{ return m_audience; }
+    inline void SetAudience(const Aws::String& value) { m_audience = value; }
+    inline void SetAudience(Aws::String&& value) { m_audience = std::move(value); }
+    inline void SetAudience(const char* value) { m_audience.assign(value); }
+    inline AssumeRoleWithSAMLResult& WithAudience(const Aws::String& value) { SetAudience(value); return *this;}
+    inline AssumeRoleWithSAMLResult& WithAudience(Aws::String&& value) { SetAudience(std::move(value)); return *this;}
+    inline AssumeRoleWithSAMLResult& WithAudience(const char* value) { SetAudience(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A hash value based on the concatenation of the following:</p> <ul> <li>
+     * <p>The <code>Issuer</code> response value.</p> </li> <li> <p>The Amazon Web
+     * Services account ID.</p> </li> <li> <p>The friendly name (the last part of the
+     * ARN) of the SAML provider in IAM.</p> </li> </ul> <p>The combination of
+     * <code>NameQualifier</code> and <code>Subject</code> can be used to uniquely
+     * identify a user.</p> <p>The following pseudocode shows how the hash value is
+     * calculated:</p> <p> <code>BASE64 ( SHA1 ( "https://example.com/saml" +
+     * "123456789012" + "/MySAMLIdP" ) )</code> </p>
+     */
+    inline const Aws::String& GetNameQualifier() const{ return m_nameQualifier; }
+    inline void SetNameQualifier(const Aws::String& value) { m_nameQualifier = value; }
+    inline void SetNameQualifier(Aws::String&& value) { m_nameQualifier = std::move(value); }
+    inline void SetNameQualifier(const char* value) { m_nameQualifier.assign(value); }
+    inline AssumeRoleWithSAMLResult& WithNameQualifier(const Aws::String& value) { SetNameQualifier(value); return *this;}
+    inline AssumeRoleWithSAMLResult& WithNameQualifier(Aws::String&& value) { SetNameQualifier(std::move(value)); return *this;}
+    inline AssumeRoleWithSAMLResult& WithNameQualifier(const char* value) { SetNameQualifier(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The value in the <code>SourceIdentity</code> attribute in the SAML assertion.
+     * </p> <p>You can require users to set a source identity value when they assume a
+     * role. You do this by using the <code>sts:SourceIdentity</code> condition key in
+     * a role trust policy. That way, actions that are taken with the role are
+     * associated with that user. After the source identity is set, the value cannot be
+     * changed. It is present in the request for all actions that are taken by the role
+     * and persists across <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts#iam-term-role-chaining">chained
+     * role</a> sessions. You can configure your SAML identity provider to use an
+     * attribute associated with your users, like user name or email, as the source
+     * identity when calling <code>AssumeRoleWithSAML</code>. You do this by adding an
+     * attribute to the SAML assertion. For more information about using source
+     * identity, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_monitor.html">Monitor
+     * and control actions taken with assumed roles</a> in the <i>IAM User
+     * Guide</i>.</p> <p>The regex used to validate this parameter is a string of
+     * characters consisting of upper- and lower-case alphanumeric characters with no
+     * spaces. You can also include underscores or any of the following characters:
+     * =,.@-</p>
+     */
+    inline const Aws::String& GetSourceIdentity() const{ return m_sourceIdentity; }
+    inline void SetSourceIdentity(const Aws::String& value) { m_sourceIdentity = value; }
+    inline void SetSourceIdentity(Aws::String&& value) { m_sourceIdentity = std::move(value); }
+    inline void SetSourceIdentity(const char* value) { m_sourceIdentity.assign(value); }
+    inline AssumeRoleWithSAMLResult& WithSourceIdentity(const Aws::String& value) { SetSourceIdentity(value); return *this;}
+    inline AssumeRoleWithSAMLResult& WithSourceIdentity(Aws::String&& value) { SetSourceIdentity(std::move(value)); return *this;}
+    inline AssumeRoleWithSAMLResult& WithSourceIdentity(const char* value) { SetSourceIdentity(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+    inline AssumeRoleWithSAMLResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+    inline AssumeRoleWithSAMLResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Credentials m_credentials;
+
+    AssumedRoleUser m_assumedRoleUser;
+
+    int m_packedPolicySize;
+
+    Aws::String m_subject;
+
+    Aws::String m_subjectType;
+
+    Aws::String m_issuer;
+
+    Aws::String m_audience;
+
+    Aws::String m_nameQualifier;
+
+    Aws::String m_sourceIdentity;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/AssumeRoleWithWebIdentityRequest.h

@@ -0,0 +1,235 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/STSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/sts/model/PolicyDescriptorType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   */
+  class AssumeRoleWithWebIdentityRequest : public STSRequest
+  {
+  public:
+    AWS_STS_API AssumeRoleWithWebIdentityRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "AssumeRoleWithWebIdentity"; }
+
+    AWS_STS_API Aws::String SerializePayload() const override;
+
+  protected:
+    AWS_STS_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    ///@{
+    /**
+     * <p>The Amazon Resource Name (ARN) of the role that the caller is assuming.</p>
+     */
+    inline const Aws::String& GetRoleArn() const{ return m_roleArn; }
+    inline bool RoleArnHasBeenSet() const { return m_roleArnHasBeenSet; }
+    inline void SetRoleArn(const Aws::String& value) { m_roleArnHasBeenSet = true; m_roleArn = value; }
+    inline void SetRoleArn(Aws::String&& value) { m_roleArnHasBeenSet = true; m_roleArn = std::move(value); }
+    inline void SetRoleArn(const char* value) { m_roleArnHasBeenSet = true; m_roleArn.assign(value); }
+    inline AssumeRoleWithWebIdentityRequest& WithRoleArn(const Aws::String& value) { SetRoleArn(value); return *this;}
+    inline AssumeRoleWithWebIdentityRequest& WithRoleArn(Aws::String&& value) { SetRoleArn(std::move(value)); return *this;}
+    inline AssumeRoleWithWebIdentityRequest& WithRoleArn(const char* value) { SetRoleArn(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>An identifier for the assumed role session. Typically, you pass the name or
+     * identifier that is associated with the user who is using your application. That
+     * way, the temporary security credentials that your application will use are
+     * associated with that user. This session name is included as part of the ARN and
+     * assumed role ID in the <code>AssumedRoleUser</code> response element.</p> <p>The
+     * regex used to validate this parameter is a string of characters consisting of
+     * upper- and lower-case alphanumeric characters with no spaces. You can also
+     * include underscores or any of the following characters: =,.@-</p>
+     */
+    inline const Aws::String& GetRoleSessionName() const{ return m_roleSessionName; }
+    inline bool RoleSessionNameHasBeenSet() const { return m_roleSessionNameHasBeenSet; }
+    inline void SetRoleSessionName(const Aws::String& value) { m_roleSessionNameHasBeenSet = true; m_roleSessionName = value; }
+    inline void SetRoleSessionName(Aws::String&& value) { m_roleSessionNameHasBeenSet = true; m_roleSessionName = std::move(value); }
+    inline void SetRoleSessionName(const char* value) { m_roleSessionNameHasBeenSet = true; m_roleSessionName.assign(value); }
+    inline AssumeRoleWithWebIdentityRequest& WithRoleSessionName(const Aws::String& value) { SetRoleSessionName(value); return *this;}
+    inline AssumeRoleWithWebIdentityRequest& WithRoleSessionName(Aws::String&& value) { SetRoleSessionName(std::move(value)); return *this;}
+    inline AssumeRoleWithWebIdentityRequest& WithRoleSessionName(const char* value) { SetRoleSessionName(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The OAuth 2.0 access token or OpenID Connect ID token that is provided by the
+     * identity provider. Your application must get this token by authenticating the
+     * user who is using your application with a web identity provider before the
+     * application makes an <code>AssumeRoleWithWebIdentity</code> call. Only tokens
+     * with RSA algorithms (RS256) are supported.</p>
+     */
+    inline const Aws::String& GetWebIdentityToken() const{ return m_webIdentityToken; }
+    inline bool WebIdentityTokenHasBeenSet() const { return m_webIdentityTokenHasBeenSet; }
+    inline void SetWebIdentityToken(const Aws::String& value) { m_webIdentityTokenHasBeenSet = true; m_webIdentityToken = value; }
+    inline void SetWebIdentityToken(Aws::String&& value) { m_webIdentityTokenHasBeenSet = true; m_webIdentityToken = std::move(value); }
+    inline void SetWebIdentityToken(const char* value) { m_webIdentityTokenHasBeenSet = true; m_webIdentityToken.assign(value); }
+    inline AssumeRoleWithWebIdentityRequest& WithWebIdentityToken(const Aws::String& value) { SetWebIdentityToken(value); return *this;}
+    inline AssumeRoleWithWebIdentityRequest& WithWebIdentityToken(Aws::String&& value) { SetWebIdentityToken(std::move(value)); return *this;}
+    inline AssumeRoleWithWebIdentityRequest& WithWebIdentityToken(const char* value) { SetWebIdentityToken(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The fully qualified host component of the domain name of the OAuth 2.0
+     * identity provider. Do not specify this value for an OpenID Connect identity
+     * provider.</p> <p>Currently <code>www.amazon.com</code> and
+     * <code>graph.facebook.com</code> are the only supported identity providers for
+     * OAuth 2.0 access tokens. Do not include URL schemes and port numbers.</p> <p>Do
+     * not specify this value for OpenID Connect ID tokens.</p>
+     */
+    inline const Aws::String& GetProviderId() const{ return m_providerId; }
+    inline bool ProviderIdHasBeenSet() const { return m_providerIdHasBeenSet; }
+    inline void SetProviderId(const Aws::String& value) { m_providerIdHasBeenSet = true; m_providerId = value; }
+    inline void SetProviderId(Aws::String&& value) { m_providerIdHasBeenSet = true; m_providerId = std::move(value); }
+    inline void SetProviderId(const char* value) { m_providerIdHasBeenSet = true; m_providerId.assign(value); }
+    inline AssumeRoleWithWebIdentityRequest& WithProviderId(const Aws::String& value) { SetProviderId(value); return *this;}
+    inline AssumeRoleWithWebIdentityRequest& WithProviderId(Aws::String&& value) { SetProviderId(std::move(value)); return *this;}
+    inline AssumeRoleWithWebIdentityRequest& WithProviderId(const char* value) { SetProviderId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The Amazon Resource Names (ARNs) of the IAM managed policies that you want to
+     * use as managed session policies. The policies must exist in the same account as
+     * the role.</p> <p>This parameter is optional. You can provide up to 10 managed
+     * policy ARNs. However, the plaintext that you use for both inline and managed
+     * session policies can't exceed 2,048 characters. For more information about ARNs,
+     * see <a
+     * href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon
+     * Resource Names (ARNs) and Amazon Web Services Service Namespaces</a> in the
+     * Amazon Web Services General Reference.</p>  <p>An Amazon Web Services
+     * conversion compresses the passed inline session policy, managed policy ARNs, and
+     * session tags into a packed binary format that has a separate limit. Your request
+     * can fail for this limit even if your plaintext meets the other requirements. The
+     * <code>PackedPolicySize</code> response element indicates by percentage how close
+     * the policies and tags for your request are to the upper size limit.</p> 
+     * <p>Passing policies to this operation returns new temporary credentials. The
+     * resulting session's permissions are the intersection of the role's
+     * identity-based policy and the session policies. You can use the role's temporary
+     * credentials in subsequent Amazon Web Services API calls to access resources in
+     * the account that owns the role. You cannot use session policies to grant more
+     * permissions than those allowed by the identity-based policy of the role that is
+     * being assumed. For more information, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">Session
+     * Policies</a> in the <i>IAM User Guide</i>.</p>
+     */
+    inline const Aws::Vector<PolicyDescriptorType>& GetPolicyArns() const{ return m_policyArns; }
+    inline bool PolicyArnsHasBeenSet() const { return m_policyArnsHasBeenSet; }
+    inline void SetPolicyArns(const Aws::Vector<PolicyDescriptorType>& value) { m_policyArnsHasBeenSet = true; m_policyArns = value; }
+    inline void SetPolicyArns(Aws::Vector<PolicyDescriptorType>&& value) { m_policyArnsHasBeenSet = true; m_policyArns = std::move(value); }
+    inline AssumeRoleWithWebIdentityRequest& WithPolicyArns(const Aws::Vector<PolicyDescriptorType>& value) { SetPolicyArns(value); return *this;}
+    inline AssumeRoleWithWebIdentityRequest& WithPolicyArns(Aws::Vector<PolicyDescriptorType>&& value) { SetPolicyArns(std::move(value)); return *this;}
+    inline AssumeRoleWithWebIdentityRequest& AddPolicyArns(const PolicyDescriptorType& value) { m_policyArnsHasBeenSet = true; m_policyArns.push_back(value); return *this; }
+    inline AssumeRoleWithWebIdentityRequest& AddPolicyArns(PolicyDescriptorType&& value) { m_policyArnsHasBeenSet = true; m_policyArns.push_back(std::move(value)); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>An IAM policy in JSON format that you want to use as an inline session
+     * policy.</p> <p>This parameter is optional. Passing policies to this operation
+     * returns new temporary credentials. The resulting session's permissions are the
+     * intersection of the role's identity-based policy and the session policies. You
+     * can use the role's temporary credentials in subsequent Amazon Web Services API
+     * calls to access resources in the account that owns the role. You cannot use
+     * session policies to grant more permissions than those allowed by the
+     * identity-based policy of the role that is being assumed. For more information,
+     * see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">Session
+     * Policies</a> in the <i>IAM User Guide</i>.</p> <p>The plaintext that you use for
+     * both inline and managed session policies can't exceed 2,048 characters. The JSON
+     * policy characters can be any ASCII character from the space character to the end
+     * of the valid character list (\u0020 through \u00FF). It can also include the tab
+     * (\u0009), linefeed (\u000A), and carriage return (\u000D) characters.</p> 
+     * <p>An Amazon Web Services conversion compresses the passed inline session
+     * policy, managed policy ARNs, and session tags into a packed binary format that
+     * has a separate limit. Your request can fail for this limit even if your
+     * plaintext meets the other requirements. The <code>PackedPolicySize</code>
+     * response element indicates by percentage how close the policies and tags for
+     * your request are to the upper size limit.</p> 
+     */
+    inline const Aws::String& GetPolicy() const{ return m_policy; }
+    inline bool PolicyHasBeenSet() const { return m_policyHasBeenSet; }
+    inline void SetPolicy(const Aws::String& value) { m_policyHasBeenSet = true; m_policy = value; }
+    inline void SetPolicy(Aws::String&& value) { m_policyHasBeenSet = true; m_policy = std::move(value); }
+    inline void SetPolicy(const char* value) { m_policyHasBeenSet = true; m_policy.assign(value); }
+    inline AssumeRoleWithWebIdentityRequest& WithPolicy(const Aws::String& value) { SetPolicy(value); return *this;}
+    inline AssumeRoleWithWebIdentityRequest& WithPolicy(Aws::String&& value) { SetPolicy(std::move(value)); return *this;}
+    inline AssumeRoleWithWebIdentityRequest& WithPolicy(const char* value) { SetPolicy(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The duration, in seconds, of the role session. The value can range from 900
+     * seconds (15 minutes) up to the maximum session duration setting for the role.
+     * This setting can have a value from 1 hour to 12 hours. If you specify a value
+     * higher than this setting, the operation fails. For example, if you specify a
+     * session duration of 12 hours, but your administrator set the maximum session
+     * duration to 6 hours, your operation fails. To learn how to view the maximum
+     * value for your role, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html#id_roles_use_view-role-max-session">View
+     * the Maximum Session Duration Setting for a Role</a> in the <i>IAM User
+     * Guide</i>.</p> <p>By default, the value is set to <code>3600</code> seconds.
+     * </p>  <p>The <code>DurationSeconds</code> parameter is separate from the
+     * duration of a console session that you might request using the returned
+     * credentials. The request to the federation endpoint for a console sign-in token
+     * takes a <code>SessionDuration</code> parameter that specifies the maximum length
+     * of the console session. For more information, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-custom-url.html">Creating
+     * a URL that Enables Federated Users to Access the Amazon Web Services Management
+     * Console</a> in the <i>IAM User Guide</i>.</p> 
+     */
+    inline int GetDurationSeconds() const{ return m_durationSeconds; }
+    inline bool DurationSecondsHasBeenSet() const { return m_durationSecondsHasBeenSet; }
+    inline void SetDurationSeconds(int value) { m_durationSecondsHasBeenSet = true; m_durationSeconds = value; }
+    inline AssumeRoleWithWebIdentityRequest& WithDurationSeconds(int value) { SetDurationSeconds(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_roleArn;
+    bool m_roleArnHasBeenSet = false;
+
+    Aws::String m_roleSessionName;
+    bool m_roleSessionNameHasBeenSet = false;
+
+    Aws::String m_webIdentityToken;
+    bool m_webIdentityTokenHasBeenSet = false;
+
+    Aws::String m_providerId;
+    bool m_providerIdHasBeenSet = false;
+
+    Aws::Vector<PolicyDescriptorType> m_policyArns;
+    bool m_policyArnsHasBeenSet = false;
+
+    Aws::String m_policy;
+    bool m_policyHasBeenSet = false;
+
+    int m_durationSeconds;
+    bool m_durationSecondsHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/AssumeRoleWithWebIdentityResult.h

@@ -0,0 +1,200 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/model/Credentials.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/sts/model/AssumedRoleUser.h>
+#include <aws/sts/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+  /**
+   * <p>Contains the response to a successful <a>AssumeRoleWithWebIdentity</a>
+   * request, including temporary Amazon Web Services credentials that can be used to
+   * make Amazon Web Services requests. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithWebIdentityResponse">AWS
+   * API Reference</a></p>
+   */
+  class AssumeRoleWithWebIdentityResult
+  {
+  public:
+    AWS_STS_API AssumeRoleWithWebIdentityResult();
+    AWS_STS_API AssumeRoleWithWebIdentityResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_STS_API AssumeRoleWithWebIdentityResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>The temporary security credentials, which include an access key ID, a secret
+     * access key, and a security token.</p>  <p>The size of the security token
+     * that STS API operations return is not fixed. We strongly recommend that you make
+     * no assumptions about the maximum size.</p> 
+     */
+    inline const Credentials& GetCredentials() const{ return m_credentials; }
+    inline void SetCredentials(const Credentials& value) { m_credentials = value; }
+    inline void SetCredentials(Credentials&& value) { m_credentials = std::move(value); }
+    inline AssumeRoleWithWebIdentityResult& WithCredentials(const Credentials& value) { SetCredentials(value); return *this;}
+    inline AssumeRoleWithWebIdentityResult& WithCredentials(Credentials&& value) { SetCredentials(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The unique user identifier that is returned by the identity provider. This
+     * identifier is associated with the <code>WebIdentityToken</code> that was
+     * submitted with the <code>AssumeRoleWithWebIdentity</code> call. The identifier
+     * is typically unique to the user and the application that acquired the
+     * <code>WebIdentityToken</code> (pairwise identifier). For OpenID Connect ID
+     * tokens, this field contains the value returned by the identity provider as the
+     * token's <code>sub</code> (Subject) claim. </p>
+     */
+    inline const Aws::String& GetSubjectFromWebIdentityToken() const{ return m_subjectFromWebIdentityToken; }
+    inline void SetSubjectFromWebIdentityToken(const Aws::String& value) { m_subjectFromWebIdentityToken = value; }
+    inline void SetSubjectFromWebIdentityToken(Aws::String&& value) { m_subjectFromWebIdentityToken = std::move(value); }
+    inline void SetSubjectFromWebIdentityToken(const char* value) { m_subjectFromWebIdentityToken.assign(value); }
+    inline AssumeRoleWithWebIdentityResult& WithSubjectFromWebIdentityToken(const Aws::String& value) { SetSubjectFromWebIdentityToken(value); return *this;}
+    inline AssumeRoleWithWebIdentityResult& WithSubjectFromWebIdentityToken(Aws::String&& value) { SetSubjectFromWebIdentityToken(std::move(value)); return *this;}
+    inline AssumeRoleWithWebIdentityResult& WithSubjectFromWebIdentityToken(const char* value) { SetSubjectFromWebIdentityToken(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The Amazon Resource Name (ARN) and the assumed role ID, which are identifiers
+     * that you can use to refer to the resulting temporary security credentials. For
+     * example, you can reference these credentials as a principal in a resource-based
+     * policy by using the ARN or assumed role ID. The ARN and ID include the
+     * <code>RoleSessionName</code> that you specified when you called
+     * <code>AssumeRole</code>. </p>
+     */
+    inline const AssumedRoleUser& GetAssumedRoleUser() const{ return m_assumedRoleUser; }
+    inline void SetAssumedRoleUser(const AssumedRoleUser& value) { m_assumedRoleUser = value; }
+    inline void SetAssumedRoleUser(AssumedRoleUser&& value) { m_assumedRoleUser = std::move(value); }
+    inline AssumeRoleWithWebIdentityResult& WithAssumedRoleUser(const AssumedRoleUser& value) { SetAssumedRoleUser(value); return *this;}
+    inline AssumeRoleWithWebIdentityResult& WithAssumedRoleUser(AssumedRoleUser&& value) { SetAssumedRoleUser(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A percentage value that indicates the packed size of the session policies and
+     * session tags combined passed in the request. The request fails if the packed
+     * size is greater than 100 percent, which means the policies and tags exceeded the
+     * allowed space.</p>
+     */
+    inline int GetPackedPolicySize() const{ return m_packedPolicySize; }
+    inline void SetPackedPolicySize(int value) { m_packedPolicySize = value; }
+    inline AssumeRoleWithWebIdentityResult& WithPackedPolicySize(int value) { SetPackedPolicySize(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p> The issuing authority of the web identity token presented. For OpenID
+     * Connect ID tokens, this contains the value of the <code>iss</code> field. For
+     * OAuth 2.0 access tokens, this contains the value of the <code>ProviderId</code>
+     * parameter that was passed in the <code>AssumeRoleWithWebIdentity</code>
+     * request.</p>
+     */
+    inline const Aws::String& GetProvider() const{ return m_provider; }
+    inline void SetProvider(const Aws::String& value) { m_provider = value; }
+    inline void SetProvider(Aws::String&& value) { m_provider = std::move(value); }
+    inline void SetProvider(const char* value) { m_provider.assign(value); }
+    inline AssumeRoleWithWebIdentityResult& WithProvider(const Aws::String& value) { SetProvider(value); return *this;}
+    inline AssumeRoleWithWebIdentityResult& WithProvider(Aws::String&& value) { SetProvider(std::move(value)); return *this;}
+    inline AssumeRoleWithWebIdentityResult& WithProvider(const char* value) { SetProvider(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The intended audience (also known as client ID) of the web identity token.
+     * This is traditionally the client identifier issued to the application that
+     * requested the web identity token.</p>
+     */
+    inline const Aws::String& GetAudience() const{ return m_audience; }
+    inline void SetAudience(const Aws::String& value) { m_audience = value; }
+    inline void SetAudience(Aws::String&& value) { m_audience = std::move(value); }
+    inline void SetAudience(const char* value) { m_audience.assign(value); }
+    inline AssumeRoleWithWebIdentityResult& WithAudience(const Aws::String& value) { SetAudience(value); return *this;}
+    inline AssumeRoleWithWebIdentityResult& WithAudience(Aws::String&& value) { SetAudience(std::move(value)); return *this;}
+    inline AssumeRoleWithWebIdentityResult& WithAudience(const char* value) { SetAudience(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The value of the source identity that is returned in the JSON web token (JWT)
+     * from the identity provider.</p> <p>You can require users to set a source
+     * identity value when they assume a role. You do this by using the
+     * <code>sts:SourceIdentity</code> condition key in a role trust policy. That way,
+     * actions that are taken with the role are associated with that user. After the
+     * source identity is set, the value cannot be changed. It is present in the
+     * request for all actions that are taken by the role and persists across <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts#iam-term-role-chaining">chained
+     * role</a> sessions. You can configure your identity provider to use an attribute
+     * associated with your users, like user name or email, as the source identity when
+     * calling <code>AssumeRoleWithWebIdentity</code>. You do this by adding a claim to
+     * the JSON web token. To learn more about OIDC tokens and claims, see <a
+     * href="https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-tokens-with-identity-providers.html">Using
+     * Tokens with User Pools</a> in the <i>Amazon Cognito Developer Guide</i>. For
+     * more information about using source identity, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_monitor.html">Monitor
+     * and control actions taken with assumed roles</a> in the <i>IAM User
+     * Guide</i>.</p> <p>The regex used to validate this parameter is a string of
+     * characters consisting of upper- and lower-case alphanumeric characters with no
+     * spaces. You can also include underscores or any of the following characters:
+     * =,.@-</p>
+     */
+    inline const Aws::String& GetSourceIdentity() const{ return m_sourceIdentity; }
+    inline void SetSourceIdentity(const Aws::String& value) { m_sourceIdentity = value; }
+    inline void SetSourceIdentity(Aws::String&& value) { m_sourceIdentity = std::move(value); }
+    inline void SetSourceIdentity(const char* value) { m_sourceIdentity.assign(value); }
+    inline AssumeRoleWithWebIdentityResult& WithSourceIdentity(const Aws::String& value) { SetSourceIdentity(value); return *this;}
+    inline AssumeRoleWithWebIdentityResult& WithSourceIdentity(Aws::String&& value) { SetSourceIdentity(std::move(value)); return *this;}
+    inline AssumeRoleWithWebIdentityResult& WithSourceIdentity(const char* value) { SetSourceIdentity(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+    inline AssumeRoleWithWebIdentityResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+    inline AssumeRoleWithWebIdentityResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Credentials m_credentials;
+
+    Aws::String m_subjectFromWebIdentityToken;
+
+    AssumedRoleUser m_assumedRoleUser;
+
+    int m_packedPolicySize;
+
+    Aws::String m_provider;
+
+    Aws::String m_audience;
+
+    Aws::String m_sourceIdentity;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/AssumedRoleUser.h

@@ -0,0 +1,87 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   * <p>The identifiers for the temporary security credentials that the operation
+   * returns.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumedRoleUser">AWS
+   * API Reference</a></p>
+   */
+  class AssumedRoleUser
+  {
+  public:
+    AWS_STS_API AssumedRoleUser();
+    AWS_STS_API AssumedRoleUser(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_STS_API AssumedRoleUser& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_STS_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    AWS_STS_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    ///@{
+    /**
+     * <p>A unique identifier that contains the role ID and the role session name of
+     * the role that is being assumed. The role ID is generated by Amazon Web Services
+     * when the role is created.</p>
+     */
+    inline const Aws::String& GetAssumedRoleId() const{ return m_assumedRoleId; }
+    inline bool AssumedRoleIdHasBeenSet() const { return m_assumedRoleIdHasBeenSet; }
+    inline void SetAssumedRoleId(const Aws::String& value) { m_assumedRoleIdHasBeenSet = true; m_assumedRoleId = value; }
+    inline void SetAssumedRoleId(Aws::String&& value) { m_assumedRoleIdHasBeenSet = true; m_assumedRoleId = std::move(value); }
+    inline void SetAssumedRoleId(const char* value) { m_assumedRoleIdHasBeenSet = true; m_assumedRoleId.assign(value); }
+    inline AssumedRoleUser& WithAssumedRoleId(const Aws::String& value) { SetAssumedRoleId(value); return *this;}
+    inline AssumedRoleUser& WithAssumedRoleId(Aws::String&& value) { SetAssumedRoleId(std::move(value)); return *this;}
+    inline AssumedRoleUser& WithAssumedRoleId(const char* value) { SetAssumedRoleId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The ARN of the temporary security credentials that are returned from the
+     * <a>AssumeRole</a> action. For more information about ARNs and how to use them in
+     * policies, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html">IAM
+     * Identifiers</a> in the <i>IAM User Guide</i>.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+    inline AssumedRoleUser& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+    inline AssumedRoleUser& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+    inline AssumedRoleUser& WithArn(const char* value) { SetArn(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_assumedRoleId;
+    bool m_assumedRoleIdHasBeenSet = false;
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/Credentials.h

@@ -0,0 +1,115 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/DateTime.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   * <p>Amazon Web Services credentials for API authentication.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/Credentials">AWS API
+   * Reference</a></p>
+   */
+  class Credentials
+  {
+  public:
+    AWS_STS_API Credentials();
+    AWS_STS_API Credentials(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_STS_API Credentials& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_STS_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    AWS_STS_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    ///@{
+    /**
+     * <p>The access key ID that identifies the temporary security credentials.</p>
+     */
+    inline const Aws::String& GetAccessKeyId() const{ return m_accessKeyId; }
+    inline bool AccessKeyIdHasBeenSet() const { return m_accessKeyIdHasBeenSet; }
+    inline void SetAccessKeyId(const Aws::String& value) { m_accessKeyIdHasBeenSet = true; m_accessKeyId = value; }
+    inline void SetAccessKeyId(Aws::String&& value) { m_accessKeyIdHasBeenSet = true; m_accessKeyId = std::move(value); }
+    inline void SetAccessKeyId(const char* value) { m_accessKeyIdHasBeenSet = true; m_accessKeyId.assign(value); }
+    inline Credentials& WithAccessKeyId(const Aws::String& value) { SetAccessKeyId(value); return *this;}
+    inline Credentials& WithAccessKeyId(Aws::String&& value) { SetAccessKeyId(std::move(value)); return *this;}
+    inline Credentials& WithAccessKeyId(const char* value) { SetAccessKeyId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The secret access key that can be used to sign requests.</p>
+     */
+    inline const Aws::String& GetSecretAccessKey() const{ return m_secretAccessKey; }
+    inline bool SecretAccessKeyHasBeenSet() const { return m_secretAccessKeyHasBeenSet; }
+    inline void SetSecretAccessKey(const Aws::String& value) { m_secretAccessKeyHasBeenSet = true; m_secretAccessKey = value; }
+    inline void SetSecretAccessKey(Aws::String&& value) { m_secretAccessKeyHasBeenSet = true; m_secretAccessKey = std::move(value); }
+    inline void SetSecretAccessKey(const char* value) { m_secretAccessKeyHasBeenSet = true; m_secretAccessKey.assign(value); }
+    inline Credentials& WithSecretAccessKey(const Aws::String& value) { SetSecretAccessKey(value); return *this;}
+    inline Credentials& WithSecretAccessKey(Aws::String&& value) { SetSecretAccessKey(std::move(value)); return *this;}
+    inline Credentials& WithSecretAccessKey(const char* value) { SetSecretAccessKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The token that users must pass to the service API to use the temporary
+     * credentials.</p>
+     */
+    inline const Aws::String& GetSessionToken() const{ return m_sessionToken; }
+    inline bool SessionTokenHasBeenSet() const { return m_sessionTokenHasBeenSet; }
+    inline void SetSessionToken(const Aws::String& value) { m_sessionTokenHasBeenSet = true; m_sessionToken = value; }
+    inline void SetSessionToken(Aws::String&& value) { m_sessionTokenHasBeenSet = true; m_sessionToken = std::move(value); }
+    inline void SetSessionToken(const char* value) { m_sessionTokenHasBeenSet = true; m_sessionToken.assign(value); }
+    inline Credentials& WithSessionToken(const Aws::String& value) { SetSessionToken(value); return *this;}
+    inline Credentials& WithSessionToken(Aws::String&& value) { SetSessionToken(std::move(value)); return *this;}
+    inline Credentials& WithSessionToken(const char* value) { SetSessionToken(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The date on which the current credentials expire.</p>
+     */
+    inline const Aws::Utils::DateTime& GetExpiration() const{ return m_expiration; }
+    inline bool ExpirationHasBeenSet() const { return m_expirationHasBeenSet; }
+    inline void SetExpiration(const Aws::Utils::DateTime& value) { m_expirationHasBeenSet = true; m_expiration = value; }
+    inline void SetExpiration(Aws::Utils::DateTime&& value) { m_expirationHasBeenSet = true; m_expiration = std::move(value); }
+    inline Credentials& WithExpiration(const Aws::Utils::DateTime& value) { SetExpiration(value); return *this;}
+    inline Credentials& WithExpiration(Aws::Utils::DateTime&& value) { SetExpiration(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_accessKeyId;
+    bool m_accessKeyIdHasBeenSet = false;
+
+    Aws::String m_secretAccessKey;
+    bool m_secretAccessKeyHasBeenSet = false;
+
+    Aws::String m_sessionToken;
+    bool m_sessionTokenHasBeenSet = false;
+
+    Aws::Utils::DateTime m_expiration;
+    bool m_expirationHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/DecodeAuthorizationMessageRequest.h

@@ -0,0 +1,60 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/STSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   */
+  class DecodeAuthorizationMessageRequest : public STSRequest
+  {
+  public:
+    AWS_STS_API DecodeAuthorizationMessageRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "DecodeAuthorizationMessage"; }
+
+    AWS_STS_API Aws::String SerializePayload() const override;
+
+  protected:
+    AWS_STS_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    ///@{
+    /**
+     * <p>The encoded message that was returned with the response.</p>
+     */
+    inline const Aws::String& GetEncodedMessage() const{ return m_encodedMessage; }
+    inline bool EncodedMessageHasBeenSet() const { return m_encodedMessageHasBeenSet; }
+    inline void SetEncodedMessage(const Aws::String& value) { m_encodedMessageHasBeenSet = true; m_encodedMessage = value; }
+    inline void SetEncodedMessage(Aws::String&& value) { m_encodedMessageHasBeenSet = true; m_encodedMessage = std::move(value); }
+    inline void SetEncodedMessage(const char* value) { m_encodedMessageHasBeenSet = true; m_encodedMessage.assign(value); }
+    inline DecodeAuthorizationMessageRequest& WithEncodedMessage(const Aws::String& value) { SetEncodedMessage(value); return *this;}
+    inline DecodeAuthorizationMessageRequest& WithEncodedMessage(Aws::String&& value) { SetEncodedMessage(std::move(value)); return *this;}
+    inline DecodeAuthorizationMessageRequest& WithEncodedMessage(const char* value) { SetEncodedMessage(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_encodedMessage;
+    bool m_encodedMessageHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/DecodeAuthorizationMessageResult.h

@@ -0,0 +1,73 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/sts/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+  /**
+   * <p>A document that contains additional information about the authorization
+   * status of a request from an encoded message that is returned in response to an
+   * Amazon Web Services request.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/DecodeAuthorizationMessageResponse">AWS
+   * API Reference</a></p>
+   */
+  class DecodeAuthorizationMessageResult
+  {
+  public:
+    AWS_STS_API DecodeAuthorizationMessageResult();
+    AWS_STS_API DecodeAuthorizationMessageResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_STS_API DecodeAuthorizationMessageResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>The API returns a response with the decoded message.</p>
+     */
+    inline const Aws::String& GetDecodedMessage() const{ return m_decodedMessage; }
+    inline void SetDecodedMessage(const Aws::String& value) { m_decodedMessage = value; }
+    inline void SetDecodedMessage(Aws::String&& value) { m_decodedMessage = std::move(value); }
+    inline void SetDecodedMessage(const char* value) { m_decodedMessage.assign(value); }
+    inline DecodeAuthorizationMessageResult& WithDecodedMessage(const Aws::String& value) { SetDecodedMessage(value); return *this;}
+    inline DecodeAuthorizationMessageResult& WithDecodedMessage(Aws::String&& value) { SetDecodedMessage(std::move(value)); return *this;}
+    inline DecodeAuthorizationMessageResult& WithDecodedMessage(const char* value) { SetDecodedMessage(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+    inline DecodeAuthorizationMessageResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+    inline DecodeAuthorizationMessageResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_decodedMessage;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/FederatedUser.h

@@ -0,0 +1,86 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   * <p>Identifiers for the federated user that is associated with the
+   * credentials.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/FederatedUser">AWS
+   * API Reference</a></p>
+   */
+  class FederatedUser
+  {
+  public:
+    AWS_STS_API FederatedUser();
+    AWS_STS_API FederatedUser(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_STS_API FederatedUser& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_STS_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    AWS_STS_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    ///@{
+    /**
+     * <p>The string that identifies the federated user associated with the
+     * credentials, similar to the unique ID of an IAM user.</p>
+     */
+    inline const Aws::String& GetFederatedUserId() const{ return m_federatedUserId; }
+    inline bool FederatedUserIdHasBeenSet() const { return m_federatedUserIdHasBeenSet; }
+    inline void SetFederatedUserId(const Aws::String& value) { m_federatedUserIdHasBeenSet = true; m_federatedUserId = value; }
+    inline void SetFederatedUserId(Aws::String&& value) { m_federatedUserIdHasBeenSet = true; m_federatedUserId = std::move(value); }
+    inline void SetFederatedUserId(const char* value) { m_federatedUserIdHasBeenSet = true; m_federatedUserId.assign(value); }
+    inline FederatedUser& WithFederatedUserId(const Aws::String& value) { SetFederatedUserId(value); return *this;}
+    inline FederatedUser& WithFederatedUserId(Aws::String&& value) { SetFederatedUserId(std::move(value)); return *this;}
+    inline FederatedUser& WithFederatedUserId(const char* value) { SetFederatedUserId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The ARN that specifies the federated user that is associated with the
+     * credentials. For more information about ARNs and how to use them in policies,
+     * see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html">IAM
+     * Identifiers</a> in the <i>IAM User Guide</i>. </p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+    inline FederatedUser& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+    inline FederatedUser& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+    inline FederatedUser& WithArn(const char* value) { SetArn(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_federatedUserId;
+    bool m_federatedUserIdHasBeenSet = false;
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/GetAccessKeyInfoRequest.h

@@ -0,0 +1,62 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/STSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   */
+  class GetAccessKeyInfoRequest : public STSRequest
+  {
+  public:
+    AWS_STS_API GetAccessKeyInfoRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "GetAccessKeyInfo"; }
+
+    AWS_STS_API Aws::String SerializePayload() const override;
+
+  protected:
+    AWS_STS_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    ///@{
+    /**
+     * <p>The identifier of an access key.</p> <p>This parameter allows (through its
+     * regex pattern) a string of characters that can consist of any upper- or
+     * lowercase letter or digit.</p>
+     */
+    inline const Aws::String& GetAccessKeyId() const{ return m_accessKeyId; }
+    inline bool AccessKeyIdHasBeenSet() const { return m_accessKeyIdHasBeenSet; }
+    inline void SetAccessKeyId(const Aws::String& value) { m_accessKeyIdHasBeenSet = true; m_accessKeyId = value; }
+    inline void SetAccessKeyId(Aws::String&& value) { m_accessKeyIdHasBeenSet = true; m_accessKeyId = std::move(value); }
+    inline void SetAccessKeyId(const char* value) { m_accessKeyIdHasBeenSet = true; m_accessKeyId.assign(value); }
+    inline GetAccessKeyInfoRequest& WithAccessKeyId(const Aws::String& value) { SetAccessKeyId(value); return *this;}
+    inline GetAccessKeyInfoRequest& WithAccessKeyId(Aws::String&& value) { SetAccessKeyId(std::move(value)); return *this;}
+    inline GetAccessKeyInfoRequest& WithAccessKeyId(const char* value) { SetAccessKeyId(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_accessKeyId;
+    bool m_accessKeyIdHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/GetAccessKeyInfoResult.h

@@ -0,0 +1,66 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/sts/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+  class GetAccessKeyInfoResult
+  {
+  public:
+    AWS_STS_API GetAccessKeyInfoResult();
+    AWS_STS_API GetAccessKeyInfoResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_STS_API GetAccessKeyInfoResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>The number used to identify the Amazon Web Services account.</p>
+     */
+    inline const Aws::String& GetAccount() const{ return m_account; }
+    inline void SetAccount(const Aws::String& value) { m_account = value; }
+    inline void SetAccount(Aws::String&& value) { m_account = std::move(value); }
+    inline void SetAccount(const char* value) { m_account.assign(value); }
+    inline GetAccessKeyInfoResult& WithAccount(const Aws::String& value) { SetAccount(value); return *this;}
+    inline GetAccessKeyInfoResult& WithAccount(Aws::String&& value) { SetAccount(std::move(value)); return *this;}
+    inline GetAccessKeyInfoResult& WithAccount(const char* value) { SetAccount(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+    inline GetAccessKeyInfoResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+    inline GetAccessKeyInfoResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_account;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/GetCallerIdentityRequest.h

@@ -0,0 +1,40 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/STSRequest.h>
+
+namespace Aws
+{
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   */
+  class GetCallerIdentityRequest : public STSRequest
+  {
+  public:
+    AWS_STS_API GetCallerIdentityRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "GetCallerIdentity"; }
+
+    AWS_STS_API Aws::String SerializePayload() const override;
+
+  protected:
+    AWS_STS_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/GetCallerIdentityResult.h

@@ -0,0 +1,109 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/sts/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+  /**
+   * <p>Contains the response to a successful <a>GetCallerIdentity</a> request,
+   * including information about the entity making the request.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetCallerIdentityResponse">AWS
+   * API Reference</a></p>
+   */
+  class GetCallerIdentityResult
+  {
+  public:
+    AWS_STS_API GetCallerIdentityResult();
+    AWS_STS_API GetCallerIdentityResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_STS_API GetCallerIdentityResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>The unique identifier of the calling entity. The exact value depends on the
+     * type of entity that is making the call. The values returned are those listed in
+     * the <b>aws:userid</b> column in the <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#principaltable">Principal
+     * table</a> found on the <b>Policy Variables</b> reference page in the <i>IAM User
+     * Guide</i>.</p>
+     */
+    inline const Aws::String& GetUserId() const{ return m_userId; }
+    inline void SetUserId(const Aws::String& value) { m_userId = value; }
+    inline void SetUserId(Aws::String&& value) { m_userId = std::move(value); }
+    inline void SetUserId(const char* value) { m_userId.assign(value); }
+    inline GetCallerIdentityResult& WithUserId(const Aws::String& value) { SetUserId(value); return *this;}
+    inline GetCallerIdentityResult& WithUserId(Aws::String&& value) { SetUserId(std::move(value)); return *this;}
+    inline GetCallerIdentityResult& WithUserId(const char* value) { SetUserId(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The Amazon Web Services account ID number of the account that owns or
+     * contains the calling entity.</p>
+     */
+    inline const Aws::String& GetAccount() const{ return m_account; }
+    inline void SetAccount(const Aws::String& value) { m_account = value; }
+    inline void SetAccount(Aws::String&& value) { m_account = std::move(value); }
+    inline void SetAccount(const char* value) { m_account.assign(value); }
+    inline GetCallerIdentityResult& WithAccount(const Aws::String& value) { SetAccount(value); return *this;}
+    inline GetCallerIdentityResult& WithAccount(Aws::String&& value) { SetAccount(std::move(value)); return *this;}
+    inline GetCallerIdentityResult& WithAccount(const char* value) { SetAccount(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The Amazon Web Services ARN associated with the calling entity.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+    inline void SetArn(const Aws::String& value) { m_arn = value; }
+    inline void SetArn(Aws::String&& value) { m_arn = std::move(value); }
+    inline void SetArn(const char* value) { m_arn.assign(value); }
+    inline GetCallerIdentityResult& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+    inline GetCallerIdentityResult& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+    inline GetCallerIdentityResult& WithArn(const char* value) { SetArn(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+    inline GetCallerIdentityResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+    inline GetCallerIdentityResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_userId;
+
+    Aws::String m_account;
+
+    Aws::String m_arn;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/GetFederationTokenRequest.h

@@ -0,0 +1,222 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/STSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/core/utils/memory/stl/AWSVector.h>
+#include <aws/sts/model/PolicyDescriptorType.h>
+#include <aws/sts/model/Tag.h>
+#include <utility>
+
+namespace Aws
+{
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   */
+  class GetFederationTokenRequest : public STSRequest
+  {
+  public:
+    AWS_STS_API GetFederationTokenRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "GetFederationToken"; }
+
+    AWS_STS_API Aws::String SerializePayload() const override;
+
+  protected:
+    AWS_STS_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    ///@{
+    /**
+     * <p>The name of the federated user. The name is used as an identifier for the
+     * temporary security credentials (such as <code>Bob</code>). For example, you can
+     * reference the federated user name in a resource-based policy, such as in an
+     * Amazon S3 bucket policy.</p> <p>The regex used to validate this parameter is a
+     * string of characters consisting of upper- and lower-case alphanumeric characters
+     * with no spaces. You can also include underscores or any of the following
+     * characters: =,.@-</p>
+     */
+    inline const Aws::String& GetName() const{ return m_name; }
+    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
+    inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
+    inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
+    inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
+    inline GetFederationTokenRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
+    inline GetFederationTokenRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
+    inline GetFederationTokenRequest& WithName(const char* value) { SetName(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>An IAM policy in JSON format that you want to use as an inline session
+     * policy.</p> <p>You must pass an inline or managed <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">session
+     * policy</a> to this operation. You can pass a single JSON policy document to use
+     * as an inline session policy. You can also specify up to 10 managed policy Amazon
+     * Resource Names (ARNs) to use as managed session policies.</p> <p>This parameter
+     * is optional. However, if you do not pass any session policies, then the
+     * resulting federated user session has no permissions.</p> <p>When you pass
+     * session policies, the session permissions are the intersection of the IAM user
+     * policies and the session policies that you pass. This gives you a way to further
+     * restrict the permissions for a federated user. You cannot use session policies
+     * to grant more permissions than those that are defined in the permissions policy
+     * of the IAM user. For more information, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">Session
+     * Policies</a> in the <i>IAM User Guide</i>.</p> <p>The resulting credentials can
+     * be used to access a resource that has a resource-based policy. If that policy
+     * specifically references the federated user session in the <code>Principal</code>
+     * element of the policy, the session has the permissions allowed by the policy.
+     * These permissions are granted in addition to the permissions that are granted by
+     * the session policies.</p> <p>The plaintext that you use for both inline and
+     * managed session policies can't exceed 2,048 characters. The JSON policy
+     * characters can be any ASCII character from the space character to the end of the
+     * valid character list (\u0020 through \u00FF). It can also include the tab
+     * (\u0009), linefeed (\u000A), and carriage return (\u000D) characters.</p> 
+     * <p>An Amazon Web Services conversion compresses the passed inline session
+     * policy, managed policy ARNs, and session tags into a packed binary format that
+     * has a separate limit. Your request can fail for this limit even if your
+     * plaintext meets the other requirements. The <code>PackedPolicySize</code>
+     * response element indicates by percentage how close the policies and tags for
+     * your request are to the upper size limit.</p> 
+     */
+    inline const Aws::String& GetPolicy() const{ return m_policy; }
+    inline bool PolicyHasBeenSet() const { return m_policyHasBeenSet; }
+    inline void SetPolicy(const Aws::String& value) { m_policyHasBeenSet = true; m_policy = value; }
+    inline void SetPolicy(Aws::String&& value) { m_policyHasBeenSet = true; m_policy = std::move(value); }
+    inline void SetPolicy(const char* value) { m_policyHasBeenSet = true; m_policy.assign(value); }
+    inline GetFederationTokenRequest& WithPolicy(const Aws::String& value) { SetPolicy(value); return *this;}
+    inline GetFederationTokenRequest& WithPolicy(Aws::String&& value) { SetPolicy(std::move(value)); return *this;}
+    inline GetFederationTokenRequest& WithPolicy(const char* value) { SetPolicy(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The Amazon Resource Names (ARNs) of the IAM managed policies that you want to
+     * use as a managed session policy. The policies must exist in the same account as
+     * the IAM user that is requesting federated access.</p> <p>You must pass an inline
+     * or managed <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">session
+     * policy</a> to this operation. You can pass a single JSON policy document to use
+     * as an inline session policy. You can also specify up to 10 managed policy Amazon
+     * Resource Names (ARNs) to use as managed session policies. The plaintext that you
+     * use for both inline and managed session policies can't exceed 2,048 characters.
+     * You can provide up to 10 managed policy ARNs. For more information about ARNs,
+     * see <a
+     * href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon
+     * Resource Names (ARNs) and Amazon Web Services Service Namespaces</a> in the
+     * Amazon Web Services General Reference.</p> <p>This parameter is optional.
+     * However, if you do not pass any session policies, then the resulting federated
+     * user session has no permissions.</p> <p>When you pass session policies, the
+     * session permissions are the intersection of the IAM user policies and the
+     * session policies that you pass. This gives you a way to further restrict the
+     * permissions for a federated user. You cannot use session policies to grant more
+     * permissions than those that are defined in the permissions policy of the IAM
+     * user. For more information, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session">Session
+     * Policies</a> in the <i>IAM User Guide</i>.</p> <p>The resulting credentials can
+     * be used to access a resource that has a resource-based policy. If that policy
+     * specifically references the federated user session in the <code>Principal</code>
+     * element of the policy, the session has the permissions allowed by the policy.
+     * These permissions are granted in addition to the permissions that are granted by
+     * the session policies.</p>  <p>An Amazon Web Services conversion compresses
+     * the passed inline session policy, managed policy ARNs, and session tags into a
+     * packed binary format that has a separate limit. Your request can fail for this
+     * limit even if your plaintext meets the other requirements. The
+     * <code>PackedPolicySize</code> response element indicates by percentage how close
+     * the policies and tags for your request are to the upper size limit.</p> 
+     */
+    inline const Aws::Vector<PolicyDescriptorType>& GetPolicyArns() const{ return m_policyArns; }
+    inline bool PolicyArnsHasBeenSet() const { return m_policyArnsHasBeenSet; }
+    inline void SetPolicyArns(const Aws::Vector<PolicyDescriptorType>& value) { m_policyArnsHasBeenSet = true; m_policyArns = value; }
+    inline void SetPolicyArns(Aws::Vector<PolicyDescriptorType>&& value) { m_policyArnsHasBeenSet = true; m_policyArns = std::move(value); }
+    inline GetFederationTokenRequest& WithPolicyArns(const Aws::Vector<PolicyDescriptorType>& value) { SetPolicyArns(value); return *this;}
+    inline GetFederationTokenRequest& WithPolicyArns(Aws::Vector<PolicyDescriptorType>&& value) { SetPolicyArns(std::move(value)); return *this;}
+    inline GetFederationTokenRequest& AddPolicyArns(const PolicyDescriptorType& value) { m_policyArnsHasBeenSet = true; m_policyArns.push_back(value); return *this; }
+    inline GetFederationTokenRequest& AddPolicyArns(PolicyDescriptorType&& value) { m_policyArnsHasBeenSet = true; m_policyArns.push_back(std::move(value)); return *this; }
+    ///@}
+
+    ///@{
+    /**
+     * <p>The duration, in seconds, that the session should last. Acceptable durations
+     * for federation sessions range from 900 seconds (15 minutes) to 129,600 seconds
+     * (36 hours), with 43,200 seconds (12 hours) as the default. Sessions obtained
+     * using root user credentials are restricted to a maximum of 3,600 seconds (one
+     * hour). If the specified duration is longer than one hour, the session obtained
+     * by using root user credentials defaults to one hour.</p>
+     */
+    inline int GetDurationSeconds() const{ return m_durationSeconds; }
+    inline bool DurationSecondsHasBeenSet() const { return m_durationSecondsHasBeenSet; }
+    inline void SetDurationSeconds(int value) { m_durationSecondsHasBeenSet = true; m_durationSeconds = value; }
+    inline GetFederationTokenRequest& WithDurationSeconds(int value) { SetDurationSeconds(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A list of session tags. Each session tag consists of a key name and an
+     * associated value. For more information about session tags, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html">Passing
+     * Session Tags in STS</a> in the <i>IAM User Guide</i>.</p> <p>This parameter is
+     * optional. You can pass up to 50 session tags. The plaintext session tag keys
+     * can’t exceed 128 characters and the values can’t exceed 256 characters. For
+     * these and additional limits, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-limits.html#reference_iam-limits-entity-length">IAM
+     * and STS Character Limits</a> in the <i>IAM User Guide</i>.</p>  <p>An
+     * Amazon Web Services conversion compresses the passed inline session policy,
+     * managed policy ARNs, and session tags into a packed binary format that has a
+     * separate limit. Your request can fail for this limit even if your plaintext
+     * meets the other requirements. The <code>PackedPolicySize</code> response element
+     * indicates by percentage how close the policies and tags for your request are to
+     * the upper size limit.</p>  <p>You can pass a session tag with the same
+     * key as a tag that is already attached to the user you are federating. When you
+     * do, session tags override a user tag with the same key. </p> <p>Tag key–value
+     * pairs are not case sensitive, but case is preserved. This means that you cannot
+     * have separate <code>Department</code> and <code>department</code> tag keys.
+     * Assume that the role has the <code>Department</code>=<code>Marketing</code> tag
+     * and you pass the <code>department</code>=<code>engineering</code> session tag.
+     * <code>Department</code> and <code>department</code> are not saved as separate
+     * tags, and the session tag passed in the request takes precedence over the role
+     * tag.</p>
+     */
+    inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
+    inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
+    inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
+    inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
+    inline GetFederationTokenRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
+    inline GetFederationTokenRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
+    inline GetFederationTokenRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
+    inline GetFederationTokenRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
+    ///@}
+  private:
+
+    Aws::String m_name;
+    bool m_nameHasBeenSet = false;
+
+    Aws::String m_policy;
+    bool m_policyHasBeenSet = false;
+
+    Aws::Vector<PolicyDescriptorType> m_policyArns;
+    bool m_policyArnsHasBeenSet = false;
+
+    int m_durationSeconds;
+    bool m_durationSecondsHasBeenSet = false;
+
+    Aws::Vector<Tag> m_tags;
+    bool m_tagsHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/GetFederationTokenResult.h

@@ -0,0 +1,105 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/model/Credentials.h>
+#include <aws/sts/model/FederatedUser.h>
+#include <aws/sts/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+  /**
+   * <p>Contains the response to a successful <a>GetFederationToken</a> request,
+   * including temporary Amazon Web Services credentials that can be used to make
+   * Amazon Web Services requests. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetFederationTokenResponse">AWS
+   * API Reference</a></p>
+   */
+  class GetFederationTokenResult
+  {
+  public:
+    AWS_STS_API GetFederationTokenResult();
+    AWS_STS_API GetFederationTokenResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_STS_API GetFederationTokenResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>The temporary security credentials, which include an access key ID, a secret
+     * access key, and a security (or session) token.</p>  <p>The size of the
+     * security token that STS API operations return is not fixed. We strongly
+     * recommend that you make no assumptions about the maximum size.</p> 
+     */
+    inline const Credentials& GetCredentials() const{ return m_credentials; }
+    inline void SetCredentials(const Credentials& value) { m_credentials = value; }
+    inline void SetCredentials(Credentials&& value) { m_credentials = std::move(value); }
+    inline GetFederationTokenResult& WithCredentials(const Credentials& value) { SetCredentials(value); return *this;}
+    inline GetFederationTokenResult& WithCredentials(Credentials&& value) { SetCredentials(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Identifiers for the federated user associated with the credentials (such as
+     * <code>arn:aws:sts::123456789012:federated-user/Bob</code> or
+     * <code>123456789012:Bob</code>). You can use the federated user's ARN in your
+     * resource-based policies, such as an Amazon S3 bucket policy. </p>
+     */
+    inline const FederatedUser& GetFederatedUser() const{ return m_federatedUser; }
+    inline void SetFederatedUser(const FederatedUser& value) { m_federatedUser = value; }
+    inline void SetFederatedUser(FederatedUser&& value) { m_federatedUser = std::move(value); }
+    inline GetFederationTokenResult& WithFederatedUser(const FederatedUser& value) { SetFederatedUser(value); return *this;}
+    inline GetFederationTokenResult& WithFederatedUser(FederatedUser&& value) { SetFederatedUser(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>A percentage value that indicates the packed size of the session policies and
+     * session tags combined passed in the request. The request fails if the packed
+     * size is greater than 100 percent, which means the policies and tags exceeded the
+     * allowed space.</p>
+     */
+    inline int GetPackedPolicySize() const{ return m_packedPolicySize; }
+    inline void SetPackedPolicySize(int value) { m_packedPolicySize = value; }
+    inline GetFederationTokenResult& WithPackedPolicySize(int value) { SetPackedPolicySize(value); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+    inline GetFederationTokenResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+    inline GetFederationTokenResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Credentials m_credentials;
+
+    FederatedUser m_federatedUser;
+
+    int m_packedPolicySize;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/GetSessionTokenRequest.h

@@ -0,0 +1,111 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/STSRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   */
+  class GetSessionTokenRequest : public STSRequest
+  {
+  public:
+    AWS_STS_API GetSessionTokenRequest();
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "GetSessionToken"; }
+
+    AWS_STS_API Aws::String SerializePayload() const override;
+
+  protected:
+    AWS_STS_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
+
+  public:
+
+    ///@{
+    /**
+     * <p>The duration, in seconds, that the credentials should remain valid.
+     * Acceptable durations for IAM user sessions range from 900 seconds (15 minutes)
+     * to 129,600 seconds (36 hours), with 43,200 seconds (12 hours) as the default.
+     * Sessions for Amazon Web Services account owners are restricted to a maximum of
+     * 3,600 seconds (one hour). If the duration is longer than one hour, the session
+     * for Amazon Web Services account owners defaults to one hour.</p>
+     */
+    inline int GetDurationSeconds() const{ return m_durationSeconds; }
+    inline bool DurationSecondsHasBeenSet() const { return m_durationSecondsHasBeenSet; }
+    inline void SetDurationSeconds(int value) { m_durationSecondsHasBeenSet = true; m_durationSeconds = value; }
+    inline GetSessionTokenRequest& WithDurationSeconds(int value) { SetDurationSeconds(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The identification number of the MFA device that is associated with the IAM
+     * user who is making the <code>GetSessionToken</code> call. Specify this value if
+     * the IAM user has a policy that requires MFA authentication. The value is either
+     * the serial number for a hardware device (such as <code>GAHT12345678</code>) or
+     * an Amazon Resource Name (ARN) for a virtual device (such as
+     * <code>arn:aws:iam::123456789012:mfa/user</code>). You can find the device for an
+     * IAM user by going to the Amazon Web Services Management Console and viewing the
+     * user's security credentials. </p> <p>The regex used to validate this parameter
+     * is a string of characters consisting of upper- and lower-case alphanumeric
+     * characters with no spaces. You can also include underscores or any of the
+     * following characters: =,.@:/-</p>
+     */
+    inline const Aws::String& GetSerialNumber() const{ return m_serialNumber; }
+    inline bool SerialNumberHasBeenSet() const { return m_serialNumberHasBeenSet; }
+    inline void SetSerialNumber(const Aws::String& value) { m_serialNumberHasBeenSet = true; m_serialNumber = value; }
+    inline void SetSerialNumber(Aws::String&& value) { m_serialNumberHasBeenSet = true; m_serialNumber = std::move(value); }
+    inline void SetSerialNumber(const char* value) { m_serialNumberHasBeenSet = true; m_serialNumber.assign(value); }
+    inline GetSessionTokenRequest& WithSerialNumber(const Aws::String& value) { SetSerialNumber(value); return *this;}
+    inline GetSessionTokenRequest& WithSerialNumber(Aws::String&& value) { SetSerialNumber(std::move(value)); return *this;}
+    inline GetSessionTokenRequest& WithSerialNumber(const char* value) { SetSerialNumber(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The value provided by the MFA device, if MFA is required. If any policy
+     * requires the IAM user to submit an MFA code, specify this value. If MFA
+     * authentication is required, the user must provide a code when requesting a set
+     * of temporary security credentials. A user who fails to provide the code receives
+     * an "access denied" response when requesting resources that require MFA
+     * authentication.</p> <p>The format for this parameter, as described by its regex
+     * pattern, is a sequence of six numeric digits.</p>
+     */
+    inline const Aws::String& GetTokenCode() const{ return m_tokenCode; }
+    inline bool TokenCodeHasBeenSet() const { return m_tokenCodeHasBeenSet; }
+    inline void SetTokenCode(const Aws::String& value) { m_tokenCodeHasBeenSet = true; m_tokenCode = value; }
+    inline void SetTokenCode(Aws::String&& value) { m_tokenCodeHasBeenSet = true; m_tokenCode = std::move(value); }
+    inline void SetTokenCode(const char* value) { m_tokenCodeHasBeenSet = true; m_tokenCode.assign(value); }
+    inline GetSessionTokenRequest& WithTokenCode(const Aws::String& value) { SetTokenCode(value); return *this;}
+    inline GetSessionTokenRequest& WithTokenCode(Aws::String&& value) { SetTokenCode(std::move(value)); return *this;}
+    inline GetSessionTokenRequest& WithTokenCode(const char* value) { SetTokenCode(value); return *this;}
+    ///@}
+  private:
+
+    int m_durationSeconds;
+    bool m_durationSecondsHasBeenSet = false;
+
+    Aws::String m_serialNumber;
+    bool m_serialNumberHasBeenSet = false;
+
+    Aws::String m_tokenCode;
+    bool m_tokenCodeHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/GetSessionTokenResult.h

@@ -0,0 +1,74 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/sts/model/Credentials.h>
+#include <aws/sts/model/ResponseMetadata.h>
+#include <utility>
+
+namespace Aws
+{
+template<typename RESULT_TYPE>
+class AmazonWebServiceResult;
+
+namespace Utils
+{
+namespace Xml
+{
+  class XmlDocument;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+  /**
+   * <p>Contains the response to a successful <a>GetSessionToken</a> request,
+   * including temporary Amazon Web Services credentials that can be used to make
+   * Amazon Web Services requests. </p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/GetSessionTokenResponse">AWS
+   * API Reference</a></p>
+   */
+  class GetSessionTokenResult
+  {
+  public:
+    AWS_STS_API GetSessionTokenResult();
+    AWS_STS_API GetSessionTokenResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+    AWS_STS_API GetSessionTokenResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
+
+
+    ///@{
+    /**
+     * <p>The temporary security credentials, which include an access key ID, a secret
+     * access key, and a security (or session) token.</p>  <p>The size of the
+     * security token that STS API operations return is not fixed. We strongly
+     * recommend that you make no assumptions about the maximum size.</p> 
+     */
+    inline const Credentials& GetCredentials() const{ return m_credentials; }
+    inline void SetCredentials(const Credentials& value) { m_credentials = value; }
+    inline void SetCredentials(Credentials&& value) { m_credentials = std::move(value); }
+    inline GetSessionTokenResult& WithCredentials(const Credentials& value) { SetCredentials(value); return *this;}
+    inline GetSessionTokenResult& WithCredentials(Credentials&& value) { SetCredentials(std::move(value)); return *this;}
+    ///@}
+
+    ///@{
+    
+    inline const ResponseMetadata& GetResponseMetadata() const{ return m_responseMetadata; }
+    inline void SetResponseMetadata(const ResponseMetadata& value) { m_responseMetadata = value; }
+    inline void SetResponseMetadata(ResponseMetadata&& value) { m_responseMetadata = std::move(value); }
+    inline GetSessionTokenResult& WithResponseMetadata(const ResponseMetadata& value) { SetResponseMetadata(value); return *this;}
+    inline GetSessionTokenResult& WithResponseMetadata(ResponseMetadata&& value) { SetResponseMetadata(std::move(value)); return *this;}
+    ///@}
+  private:
+
+    Credentials m_credentials;
+
+    ResponseMetadata m_responseMetadata;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/PolicyDescriptorType.h

@@ -0,0 +1,68 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   * <p>A reference to the IAM managed policy that is passed as a session policy for
+   * a role session or a federated user session.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/PolicyDescriptorType">AWS
+   * API Reference</a></p>
+   */
+  class PolicyDescriptorType
+  {
+  public:
+    AWS_STS_API PolicyDescriptorType();
+    AWS_STS_API PolicyDescriptorType(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_STS_API PolicyDescriptorType& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_STS_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    AWS_STS_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    ///@{
+    /**
+     * <p>The Amazon Resource Name (ARN) of the IAM managed policy to use as a session
+     * policy for the role. For more information about ARNs, see <a
+     * href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">Amazon
+     * Resource Names (ARNs) and Amazon Web Services Service Namespaces</a> in the
+     * <i>Amazon Web Services General Reference</i>.</p>
+     */
+    inline const Aws::String& GetArn() const{ return m_arn; }
+    inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
+    inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
+    inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
+    inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
+    inline PolicyDescriptorType& WithArn(const Aws::String& value) { SetArn(value); return *this;}
+    inline PolicyDescriptorType& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
+    inline PolicyDescriptorType& WithArn(const char* value) { SetArn(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_arn;
+    bool m_arnHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/ProvidedContext.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   * <p>Contains information about the provided context. This includes the signed and
+   * encrypted trusted context assertion and the context provider ARN from which the
+   * trusted context assertion was generated.</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/ProvidedContext">AWS
+   * API Reference</a></p>
+   */
+  class ProvidedContext
+  {
+  public:
+    AWS_STS_API ProvidedContext();
+    AWS_STS_API ProvidedContext(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_STS_API ProvidedContext& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_STS_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    AWS_STS_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    ///@{
+    /**
+     * <p>The context provider ARN from which the trusted context assertion was
+     * generated.</p>
+     */
+    inline const Aws::String& GetProviderArn() const{ return m_providerArn; }
+    inline bool ProviderArnHasBeenSet() const { return m_providerArnHasBeenSet; }
+    inline void SetProviderArn(const Aws::String& value) { m_providerArnHasBeenSet = true; m_providerArn = value; }
+    inline void SetProviderArn(Aws::String&& value) { m_providerArnHasBeenSet = true; m_providerArn = std::move(value); }
+    inline void SetProviderArn(const char* value) { m_providerArnHasBeenSet = true; m_providerArn.assign(value); }
+    inline ProvidedContext& WithProviderArn(const Aws::String& value) { SetProviderArn(value); return *this;}
+    inline ProvidedContext& WithProviderArn(Aws::String&& value) { SetProviderArn(std::move(value)); return *this;}
+    inline ProvidedContext& WithProviderArn(const char* value) { SetProviderArn(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The signed and encrypted trusted context assertion generated by the context
+     * provider. The trusted context assertion is signed and encrypted by Amazon Web
+     * Services STS.</p>
+     */
+    inline const Aws::String& GetContextAssertion() const{ return m_contextAssertion; }
+    inline bool ContextAssertionHasBeenSet() const { return m_contextAssertionHasBeenSet; }
+    inline void SetContextAssertion(const Aws::String& value) { m_contextAssertionHasBeenSet = true; m_contextAssertion = value; }
+    inline void SetContextAssertion(Aws::String&& value) { m_contextAssertionHasBeenSet = true; m_contextAssertion = std::move(value); }
+    inline void SetContextAssertion(const char* value) { m_contextAssertionHasBeenSet = true; m_contextAssertion.assign(value); }
+    inline ProvidedContext& WithContextAssertion(const Aws::String& value) { SetContextAssertion(value); return *this;}
+    inline ProvidedContext& WithContextAssertion(Aws::String&& value) { SetContextAssertion(std::move(value)); return *this;}
+    inline ProvidedContext& WithContextAssertion(const char* value) { SetContextAssertion(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_providerArn;
+    bool m_providerArnHasBeenSet = false;
+
+    Aws::String m_contextAssertion;
+    bool m_contextAssertionHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/ResponseMetadata.h

@@ -0,0 +1,56 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+
+  class ResponseMetadata
+  {
+  public:
+    AWS_STS_API ResponseMetadata();
+    AWS_STS_API ResponseMetadata(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_STS_API ResponseMetadata& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_STS_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    AWS_STS_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    ///@{
+    
+    inline const Aws::String& GetRequestId() const{ return m_requestId; }
+    inline bool RequestIdHasBeenSet() const { return m_requestIdHasBeenSet; }
+    inline void SetRequestId(const Aws::String& value) { m_requestIdHasBeenSet = true; m_requestId = value; }
+    inline void SetRequestId(Aws::String&& value) { m_requestIdHasBeenSet = true; m_requestId = std::move(value); }
+    inline void SetRequestId(const char* value) { m_requestIdHasBeenSet = true; m_requestId.assign(value); }
+    inline ResponseMetadata& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
+    inline ResponseMetadata& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
+    inline ResponseMetadata& WithRequestId(const char* value) { SetRequestId(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_requestId;
+    bool m_requestIdHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws

Plugins/GameLiftPlugin/Source/AWSSDK/Include/aws/sts/model/Tag.h

@@ -0,0 +1,93 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/sts/STS_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Xml
+{
+  class XmlNode;
+} // namespace Xml
+} // namespace Utils
+namespace STS
+{
+namespace Model
+{
+
+  /**
+   * <p>You can pass custom key-value pair attributes when you assume a role or
+   * federate a user. These are called session tags. You can then use the session
+   * tags to control access to resources. For more information, see <a
+   * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html">Tagging
+   * Amazon Web Services STS Sessions</a> in the <i>IAM User Guide</i>.</p><p><h3>See
+   * Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/Tag">AWS API
+   * Reference</a></p>
+   */
+  class Tag
+  {
+  public:
+    AWS_STS_API Tag();
+    AWS_STS_API Tag(const Aws::Utils::Xml::XmlNode& xmlNode);
+    AWS_STS_API Tag& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
+
+    AWS_STS_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
+    AWS_STS_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
+
+
+    ///@{
+    /**
+     * <p>The key for a session tag.</p> <p>You can pass up to 50 session tags. The
+     * plain text session tag keys can’t exceed 128 characters. For these and
+     * additional limits, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-limits.html#reference_iam-limits-entity-length">IAM
+     * and STS Character Limits</a> in the <i>IAM User Guide</i>.</p>
+     */
+    inline const Aws::String& GetKey() const{ return m_key; }
+    inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
+    inline void SetKey(const Aws::String& value) { m_keyHasBeenSet = true; m_key = value; }
+    inline void SetKey(Aws::String&& value) { m_keyHasBeenSet = true; m_key = std::move(value); }
+    inline void SetKey(const char* value) { m_keyHasBeenSet = true; m_key.assign(value); }
+    inline Tag& WithKey(const Aws::String& value) { SetKey(value); return *this;}
+    inline Tag& WithKey(Aws::String&& value) { SetKey(std::move(value)); return *this;}
+    inline Tag& WithKey(const char* value) { SetKey(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>The value for a session tag.</p> <p>You can pass up to 50 session tags. The
+     * plain text session tag values can’t exceed 256 characters. For these and
+     * additional limits, see <a
+     * href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-limits.html#reference_iam-limits-entity-length">IAM
+     * and STS Character Limits</a> in the <i>IAM User Guide</i>.</p>
+     */
+    inline const Aws::String& GetValue() const{ return m_value; }
+    inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
+    inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
+    inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
+    inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
+    inline Tag& WithValue(const Aws::String& value) { SetValue(value); return *this;}
+    inline Tag& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
+    inline Tag& WithValue(const char* value) { SetValue(value); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_key;
+    bool m_keyHasBeenSet = false;
+
+    Aws::String m_value;
+    bool m_valueHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace STS
+} // namespace Aws