func (c *STS) AssumeRoleWithSAMLRequest(input *AssumeRoleWithSAMLInput) AssumeRoleWithSAMLRequest {
	op := &aws.Operation{
		Name:       opAssumeRoleWithSAML,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AssumeRoleWithSAMLInput{}
	}
	output := &AssumeRoleWithSAMLOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}
	return AssumeRoleWithSAMLRequest{Request: req, Input: input, Copy: c.AssumeRoleWithSAMLRequest}
}
AssumeRoleWithSAMLRequest returns a request value for making API operation for
AWS Security Token Service.

Returns a set of temporary security credentials for users who have been authenticated
via a SAML authentication response. This operation provides a mechanism for
tying an enterprise identity store or directory to role-based AWS access
without user-specific credentials or configuration. For a comparison of AssumeRoleWithSAML
with the other APIs that produce temporary credentials, see Requesting Temporary
Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)
and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison)
in the IAM User Guide.

The temporary security credentials returned by this operation consist of
an access key ID, a secret access key, and a security token. Applications
can use these temporary security credentials to sign calls to AWS services.

The temporary security credentials are valid for the duration that you specified
when calling AssumeRole, or until the time specified in the SAML authentication
response's SessionNotOnOrAfter value, whichever is shorter. The duration
can be from 900 seconds (15 minutes) to a maximum of 3600 seconds (1 hour).
The default is 1 hour.

The temporary security credentials created by AssumeRoleWithSAML can be used
to make API calls to any AWS service with the following exception: you cannot
call the STS service's GetFederationToken or GetSessionToken APIs.

Optionally, you can pass an IAM access policy to this operation. If you choose
not to pass a policy, the temporary security credentials that are returned
by the operation have the permissions that are defined in the access policy
of the role that is being assumed. If you pass a policy to this operation,
the temporary security credentials that are returned by the operation have
the permissions that are allowed by the intersection of both the access policy
of the role that is being assumed, and the policy that you pass. This means
that both policies must grant the permission for the action to be allowed.
This gives you a way to further restrict the permissions for the resulting
temporary security credentials. You cannot use the passed policy to grant
permissions that are in excess of those allowed by the access policy of the
role that is being assumed. For more information, see Permissions for AssumeRole,
AssumeRoleWithSAML, and AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
in the IAM User Guide.

Before your application can call AssumeRoleWithSAML, you must configure your
SAML identity provider (IdP) to issue the claims required by AWS. Additionally,
you must use AWS Identity and Access Management (IAM) to create a SAML provider
entity in your AWS account that represents your identity provider, and create
an IAM role that specifies this SAML provider in its trust policy.

Calling AssumeRoleWithSAML does not require the use of AWS security credentials.
The identity of the caller is validated by using keys in the metadata document
that is uploaded for the SAML provider entity for your identity provider.

Calling AssumeRoleWithSAML can result in an entry in your AWS CloudTrail
logs. The entry includes the value in the NameID element of the SAML assertion.
We recommend that you use a NameIDType that is not associated with any personally
identifiable information (PII). For example, you could instead use the Persistent
Identifier (urn:oasis:names:tc:SAML:2.0:nameid-format:persistent).

For more information, see the following resources:

* About SAML 2.0-based Federation (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html)
in the IAM User Guide.

* Creating SAML Identity Providers (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml.html)
in the IAM User Guide.

* Configuring a Relying Party and Claims (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml_relying-party.html)
in the IAM User Guide.

* Creating a Role for SAML 2.0 Federation (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)
in the IAM User Guide.

// Example sending a request using the AssumeRoleWithSAMLRequest method.
req := client.AssumeRoleWithSAMLRequest(params)
resp, err := req.Send()
if err == nil {
fmt.Println(resp)
}

Please also see https://docs.aws.amazon.com/goto/WebAPI/sts-2011-06-15/AssumeRoleWithSAML
package sts
import (
	"time"
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/internal/awsutil"
)
const opAssumeRole = "AssumeRole"
type AssumeRoleRequest struct {
	*aws.Request
	Input *AssumeRoleInput
	Copy  func(*AssumeRoleInput) AssumeRoleRequest
}
func (r AssumeRoleRequest) Send() (*AssumeRoleOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*AssumeRoleOutput), nil
}
func (c *STS) AssumeRoleRequest(input *AssumeRoleInput) AssumeRoleRequest {
	op := &aws.Operation{
		Name:       opAssumeRole,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}
	if input == nil {
		input = &AssumeRoleInput{}
	}
	output := &AssumeRoleOutput{}
	req := c.newRequest(op, input, output)
	output.responseMetadata = aws.Response{Request: req}
	return AssumeRoleRequest{Request: req, Input: input, Copy: c.AssumeRoleRequest}
}
const opAssumeRoleWithSAML = "AssumeRoleWithSAML"
type AssumeRoleWithSAMLRequest struct {
	*aws.Request
	Input *AssumeRoleWithSAMLInput
	Copy  func(*AssumeRoleWithSAMLInput) AssumeRoleWithSAMLRequest
}
func (r AssumeRoleWithSAMLRequest) Send() (*AssumeRoleWithSAMLOutput, error) {
	err := r.Request.Send()
	if err != nil {
		return nil, err
	}
	return r.Request.Data.(*AssumeRoleWithSAMLOutput), nil
}