iam.go

// Generated by github.com/temporalio/temporal-aws-sdk-generator
// from github.com/aws/aws-sdk-go version 1.35.7

package iam

import (
	"context"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/request"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/iam"
	"github.com/aws/aws-sdk-go/service/iam/iamiface"

	"github.com/banzaicloud/cadence-aws-sdk/internal"
)

// ensure that imports are valid even if not used by the generated code
var _ = internal.SetClientToken

type _ request.Option

// SessionFactory returns an aws.Session based on the activity context.
type SessionFactory interface {
	Session(ctx context.Context) (*session.Session, error)
}

type Activities struct {
	client iamiface.IAMAPI

	sessionFactory SessionFactory
}

func NewActivities(sess *session.Session, config ...*aws.Config) *Activities {
	client := iam.New(sess, config...)
	return &Activities{client: client}
}

func NewActivitiesWithSessionFactory(sessionFactory SessionFactory) *Activities {
	return &Activities{sessionFactory: sessionFactory}
}

func (a *Activities) getClient(ctx context.Context) (iamiface.IAMAPI, error) {
	if a.client != nil { // No need to protect with mutex: we know the client never changes
		return a.client, nil
	}

	sess, err := a.sessionFactory.Session(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}

	return iam.New(sess), nil
}

func (a *Activities) AddClientIDToOpenIDConnectProvider(ctx context.Context, input *iam.AddClientIDToOpenIDConnectProviderInput) (*iam.AddClientIDToOpenIDConnectProviderOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.AddClientIDToOpenIDConnectProviderWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) AddRoleToInstanceProfile(ctx context.Context, input *iam.AddRoleToInstanceProfileInput) (*iam.AddRoleToInstanceProfileOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.AddRoleToInstanceProfileWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) AddUserToGroup(ctx context.Context, input *iam.AddUserToGroupInput) (*iam.AddUserToGroupOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.AddUserToGroupWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) AttachGroupPolicy(ctx context.Context, input *iam.AttachGroupPolicyInput) (*iam.AttachGroupPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.AttachGroupPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) AttachRolePolicy(ctx context.Context, input *iam.AttachRolePolicyInput) (*iam.AttachRolePolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.AttachRolePolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) AttachUserPolicy(ctx context.Context, input *iam.AttachUserPolicyInput) (*iam.AttachUserPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.AttachUserPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ChangePassword(ctx context.Context, input *iam.ChangePasswordInput) (*iam.ChangePasswordOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ChangePasswordWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreateAccessKey(ctx context.Context, input *iam.CreateAccessKeyInput) (*iam.CreateAccessKeyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreateAccessKeyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreateAccountAlias(ctx context.Context, input *iam.CreateAccountAliasInput) (*iam.CreateAccountAliasOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreateAccountAliasWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreateGroup(ctx context.Context, input *iam.CreateGroupInput) (*iam.CreateGroupOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreateGroupWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreateInstanceProfile(ctx context.Context, input *iam.CreateInstanceProfileInput) (*iam.CreateInstanceProfileOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreateInstanceProfileWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreateLoginProfile(ctx context.Context, input *iam.CreateLoginProfileInput) (*iam.CreateLoginProfileOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreateLoginProfileWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreateOpenIDConnectProvider(ctx context.Context, input *iam.CreateOpenIDConnectProviderInput) (*iam.CreateOpenIDConnectProviderOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreateOpenIDConnectProviderWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreatePolicy(ctx context.Context, input *iam.CreatePolicyInput) (*iam.CreatePolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreatePolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreatePolicyVersion(ctx context.Context, input *iam.CreatePolicyVersionInput) (*iam.CreatePolicyVersionOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreatePolicyVersionWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreateRole(ctx context.Context, input *iam.CreateRoleInput) (*iam.CreateRoleOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreateRoleWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreateSAMLProvider(ctx context.Context, input *iam.CreateSAMLProviderInput) (*iam.CreateSAMLProviderOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreateSAMLProviderWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreateServiceLinkedRole(ctx context.Context, input *iam.CreateServiceLinkedRoleInput) (*iam.CreateServiceLinkedRoleOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreateServiceLinkedRoleWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreateServiceSpecificCredential(ctx context.Context, input *iam.CreateServiceSpecificCredentialInput) (*iam.CreateServiceSpecificCredentialOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreateServiceSpecificCredentialWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreateUser(ctx context.Context, input *iam.CreateUserInput) (*iam.CreateUserOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreateUserWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) CreateVirtualMFADevice(ctx context.Context, input *iam.CreateVirtualMFADeviceInput) (*iam.CreateVirtualMFADeviceOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.CreateVirtualMFADeviceWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeactivateMFADevice(ctx context.Context, input *iam.DeactivateMFADeviceInput) (*iam.DeactivateMFADeviceOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeactivateMFADeviceWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteAccessKey(ctx context.Context, input *iam.DeleteAccessKeyInput) (*iam.DeleteAccessKeyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteAccessKeyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteAccountAlias(ctx context.Context, input *iam.DeleteAccountAliasInput) (*iam.DeleteAccountAliasOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteAccountAliasWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteAccountPasswordPolicy(ctx context.Context, input *iam.DeleteAccountPasswordPolicyInput) (*iam.DeleteAccountPasswordPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteAccountPasswordPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteGroup(ctx context.Context, input *iam.DeleteGroupInput) (*iam.DeleteGroupOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteGroupWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteGroupPolicy(ctx context.Context, input *iam.DeleteGroupPolicyInput) (*iam.DeleteGroupPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteGroupPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteInstanceProfile(ctx context.Context, input *iam.DeleteInstanceProfileInput) (*iam.DeleteInstanceProfileOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteInstanceProfileWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteLoginProfile(ctx context.Context, input *iam.DeleteLoginProfileInput) (*iam.DeleteLoginProfileOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteLoginProfileWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteOpenIDConnectProvider(ctx context.Context, input *iam.DeleteOpenIDConnectProviderInput) (*iam.DeleteOpenIDConnectProviderOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteOpenIDConnectProviderWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeletePolicy(ctx context.Context, input *iam.DeletePolicyInput) (*iam.DeletePolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeletePolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeletePolicyVersion(ctx context.Context, input *iam.DeletePolicyVersionInput) (*iam.DeletePolicyVersionOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeletePolicyVersionWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteRole(ctx context.Context, input *iam.DeleteRoleInput) (*iam.DeleteRoleOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteRoleWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteRolePermissionsBoundary(ctx context.Context, input *iam.DeleteRolePermissionsBoundaryInput) (*iam.DeleteRolePermissionsBoundaryOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteRolePermissionsBoundaryWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteRolePolicy(ctx context.Context, input *iam.DeleteRolePolicyInput) (*iam.DeleteRolePolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteRolePolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteSAMLProvider(ctx context.Context, input *iam.DeleteSAMLProviderInput) (*iam.DeleteSAMLProviderOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteSAMLProviderWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteSSHPublicKey(ctx context.Context, input *iam.DeleteSSHPublicKeyInput) (*iam.DeleteSSHPublicKeyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteSSHPublicKeyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteServerCertificate(ctx context.Context, input *iam.DeleteServerCertificateInput) (*iam.DeleteServerCertificateOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteServerCertificateWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteServiceLinkedRole(ctx context.Context, input *iam.DeleteServiceLinkedRoleInput) (*iam.DeleteServiceLinkedRoleOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteServiceLinkedRoleWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteServiceSpecificCredential(ctx context.Context, input *iam.DeleteServiceSpecificCredentialInput) (*iam.DeleteServiceSpecificCredentialOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteServiceSpecificCredentialWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteSigningCertificate(ctx context.Context, input *iam.DeleteSigningCertificateInput) (*iam.DeleteSigningCertificateOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteSigningCertificateWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteUser(ctx context.Context, input *iam.DeleteUserInput) (*iam.DeleteUserOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteUserWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteUserPermissionsBoundary(ctx context.Context, input *iam.DeleteUserPermissionsBoundaryInput) (*iam.DeleteUserPermissionsBoundaryOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteUserPermissionsBoundaryWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteUserPolicy(ctx context.Context, input *iam.DeleteUserPolicyInput) (*iam.DeleteUserPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteUserPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DeleteVirtualMFADevice(ctx context.Context, input *iam.DeleteVirtualMFADeviceInput) (*iam.DeleteVirtualMFADeviceOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DeleteVirtualMFADeviceWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DetachGroupPolicy(ctx context.Context, input *iam.DetachGroupPolicyInput) (*iam.DetachGroupPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DetachGroupPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DetachRolePolicy(ctx context.Context, input *iam.DetachRolePolicyInput) (*iam.DetachRolePolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DetachRolePolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) DetachUserPolicy(ctx context.Context, input *iam.DetachUserPolicyInput) (*iam.DetachUserPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.DetachUserPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) EnableMFADevice(ctx context.Context, input *iam.EnableMFADeviceInput) (*iam.EnableMFADeviceOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.EnableMFADeviceWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GenerateCredentialReport(ctx context.Context, input *iam.GenerateCredentialReportInput) (*iam.GenerateCredentialReportOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GenerateCredentialReportWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GenerateOrganizationsAccessReport(ctx context.Context, input *iam.GenerateOrganizationsAccessReportInput) (*iam.GenerateOrganizationsAccessReportOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GenerateOrganizationsAccessReportWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GenerateServiceLastAccessedDetails(ctx context.Context, input *iam.GenerateServiceLastAccessedDetailsInput) (*iam.GenerateServiceLastAccessedDetailsOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GenerateServiceLastAccessedDetailsWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetAccessKeyLastUsed(ctx context.Context, input *iam.GetAccessKeyLastUsedInput) (*iam.GetAccessKeyLastUsedOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetAccessKeyLastUsedWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetAccountAuthorizationDetails(ctx context.Context, input *iam.GetAccountAuthorizationDetailsInput) (*iam.GetAccountAuthorizationDetailsOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetAccountAuthorizationDetailsWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetAccountPasswordPolicy(ctx context.Context, input *iam.GetAccountPasswordPolicyInput) (*iam.GetAccountPasswordPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetAccountPasswordPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetAccountSummary(ctx context.Context, input *iam.GetAccountSummaryInput) (*iam.GetAccountSummaryOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetAccountSummaryWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetContextKeysForCustomPolicy(ctx context.Context, input *iam.GetContextKeysForCustomPolicyInput) (*iam.GetContextKeysForPolicyResponse, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetContextKeysForCustomPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetContextKeysForPrincipalPolicy(ctx context.Context, input *iam.GetContextKeysForPrincipalPolicyInput) (*iam.GetContextKeysForPolicyResponse, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetContextKeysForPrincipalPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetCredentialReport(ctx context.Context, input *iam.GetCredentialReportInput) (*iam.GetCredentialReportOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetCredentialReportWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetGroup(ctx context.Context, input *iam.GetGroupInput) (*iam.GetGroupOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetGroupWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetGroupPolicy(ctx context.Context, input *iam.GetGroupPolicyInput) (*iam.GetGroupPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetGroupPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetInstanceProfile(ctx context.Context, input *iam.GetInstanceProfileInput) (*iam.GetInstanceProfileOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetInstanceProfileWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetLoginProfile(ctx context.Context, input *iam.GetLoginProfileInput) (*iam.GetLoginProfileOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetLoginProfileWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetOpenIDConnectProvider(ctx context.Context, input *iam.GetOpenIDConnectProviderInput) (*iam.GetOpenIDConnectProviderOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetOpenIDConnectProviderWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetOrganizationsAccessReport(ctx context.Context, input *iam.GetOrganizationsAccessReportInput) (*iam.GetOrganizationsAccessReportOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetOrganizationsAccessReportWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetPolicy(ctx context.Context, input *iam.GetPolicyInput) (*iam.GetPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetPolicyVersion(ctx context.Context, input *iam.GetPolicyVersionInput) (*iam.GetPolicyVersionOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetPolicyVersionWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetRole(ctx context.Context, input *iam.GetRoleInput) (*iam.GetRoleOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetRoleWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetRolePolicy(ctx context.Context, input *iam.GetRolePolicyInput) (*iam.GetRolePolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetRolePolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetSAMLProvider(ctx context.Context, input *iam.GetSAMLProviderInput) (*iam.GetSAMLProviderOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetSAMLProviderWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetSSHPublicKey(ctx context.Context, input *iam.GetSSHPublicKeyInput) (*iam.GetSSHPublicKeyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetSSHPublicKeyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetServerCertificate(ctx context.Context, input *iam.GetServerCertificateInput) (*iam.GetServerCertificateOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetServerCertificateWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetServiceLastAccessedDetails(ctx context.Context, input *iam.GetServiceLastAccessedDetailsInput) (*iam.GetServiceLastAccessedDetailsOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetServiceLastAccessedDetailsWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetServiceLastAccessedDetailsWithEntities(ctx context.Context, input *iam.GetServiceLastAccessedDetailsWithEntitiesInput) (*iam.GetServiceLastAccessedDetailsWithEntitiesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetServiceLastAccessedDetailsWithEntitiesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetServiceLinkedRoleDeletionStatus(ctx context.Context, input *iam.GetServiceLinkedRoleDeletionStatusInput) (*iam.GetServiceLinkedRoleDeletionStatusOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetServiceLinkedRoleDeletionStatusWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetUser(ctx context.Context, input *iam.GetUserInput) (*iam.GetUserOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetUserWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) GetUserPolicy(ctx context.Context, input *iam.GetUserPolicyInput) (*iam.GetUserPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.GetUserPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListAccessKeys(ctx context.Context, input *iam.ListAccessKeysInput) (*iam.ListAccessKeysOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListAccessKeysWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListAccountAliases(ctx context.Context, input *iam.ListAccountAliasesInput) (*iam.ListAccountAliasesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListAccountAliasesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListAttachedGroupPolicies(ctx context.Context, input *iam.ListAttachedGroupPoliciesInput) (*iam.ListAttachedGroupPoliciesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListAttachedGroupPoliciesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListAttachedRolePolicies(ctx context.Context, input *iam.ListAttachedRolePoliciesInput) (*iam.ListAttachedRolePoliciesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListAttachedRolePoliciesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListAttachedUserPolicies(ctx context.Context, input *iam.ListAttachedUserPoliciesInput) (*iam.ListAttachedUserPoliciesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListAttachedUserPoliciesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListEntitiesForPolicy(ctx context.Context, input *iam.ListEntitiesForPolicyInput) (*iam.ListEntitiesForPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListEntitiesForPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListGroupPolicies(ctx context.Context, input *iam.ListGroupPoliciesInput) (*iam.ListGroupPoliciesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListGroupPoliciesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListGroups(ctx context.Context, input *iam.ListGroupsInput) (*iam.ListGroupsOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListGroupsWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListGroupsForUser(ctx context.Context, input *iam.ListGroupsForUserInput) (*iam.ListGroupsForUserOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListGroupsForUserWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListInstanceProfiles(ctx context.Context, input *iam.ListInstanceProfilesInput) (*iam.ListInstanceProfilesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListInstanceProfilesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListInstanceProfilesForRole(ctx context.Context, input *iam.ListInstanceProfilesForRoleInput) (*iam.ListInstanceProfilesForRoleOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListInstanceProfilesForRoleWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListMFADevices(ctx context.Context, input *iam.ListMFADevicesInput) (*iam.ListMFADevicesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListMFADevicesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListOpenIDConnectProviders(ctx context.Context, input *iam.ListOpenIDConnectProvidersInput) (*iam.ListOpenIDConnectProvidersOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListOpenIDConnectProvidersWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListPolicies(ctx context.Context, input *iam.ListPoliciesInput) (*iam.ListPoliciesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListPoliciesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListPoliciesGrantingServiceAccess(ctx context.Context, input *iam.ListPoliciesGrantingServiceAccessInput) (*iam.ListPoliciesGrantingServiceAccessOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListPoliciesGrantingServiceAccessWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListPolicyVersions(ctx context.Context, input *iam.ListPolicyVersionsInput) (*iam.ListPolicyVersionsOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListPolicyVersionsWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListRolePolicies(ctx context.Context, input *iam.ListRolePoliciesInput) (*iam.ListRolePoliciesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListRolePoliciesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListRoleTags(ctx context.Context, input *iam.ListRoleTagsInput) (*iam.ListRoleTagsOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListRoleTagsWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListRoles(ctx context.Context, input *iam.ListRolesInput) (*iam.ListRolesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListRolesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListSAMLProviders(ctx context.Context, input *iam.ListSAMLProvidersInput) (*iam.ListSAMLProvidersOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListSAMLProvidersWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListSSHPublicKeys(ctx context.Context, input *iam.ListSSHPublicKeysInput) (*iam.ListSSHPublicKeysOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListSSHPublicKeysWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListServerCertificates(ctx context.Context, input *iam.ListServerCertificatesInput) (*iam.ListServerCertificatesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListServerCertificatesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListServiceSpecificCredentials(ctx context.Context, input *iam.ListServiceSpecificCredentialsInput) (*iam.ListServiceSpecificCredentialsOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListServiceSpecificCredentialsWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListSigningCertificates(ctx context.Context, input *iam.ListSigningCertificatesInput) (*iam.ListSigningCertificatesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListSigningCertificatesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListUserPolicies(ctx context.Context, input *iam.ListUserPoliciesInput) (*iam.ListUserPoliciesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListUserPoliciesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListUserTags(ctx context.Context, input *iam.ListUserTagsInput) (*iam.ListUserTagsOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListUserTagsWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListUsers(ctx context.Context, input *iam.ListUsersInput) (*iam.ListUsersOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListUsersWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ListVirtualMFADevices(ctx context.Context, input *iam.ListVirtualMFADevicesInput) (*iam.ListVirtualMFADevicesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ListVirtualMFADevicesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) PutGroupPolicy(ctx context.Context, input *iam.PutGroupPolicyInput) (*iam.PutGroupPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.PutGroupPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) PutRolePermissionsBoundary(ctx context.Context, input *iam.PutRolePermissionsBoundaryInput) (*iam.PutRolePermissionsBoundaryOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.PutRolePermissionsBoundaryWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) PutRolePolicy(ctx context.Context, input *iam.PutRolePolicyInput) (*iam.PutRolePolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.PutRolePolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) PutUserPermissionsBoundary(ctx context.Context, input *iam.PutUserPermissionsBoundaryInput) (*iam.PutUserPermissionsBoundaryOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.PutUserPermissionsBoundaryWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) PutUserPolicy(ctx context.Context, input *iam.PutUserPolicyInput) (*iam.PutUserPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.PutUserPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) RemoveClientIDFromOpenIDConnectProvider(ctx context.Context, input *iam.RemoveClientIDFromOpenIDConnectProviderInput) (*iam.RemoveClientIDFromOpenIDConnectProviderOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.RemoveClientIDFromOpenIDConnectProviderWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) RemoveRoleFromInstanceProfile(ctx context.Context, input *iam.RemoveRoleFromInstanceProfileInput) (*iam.RemoveRoleFromInstanceProfileOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.RemoveRoleFromInstanceProfileWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) RemoveUserFromGroup(ctx context.Context, input *iam.RemoveUserFromGroupInput) (*iam.RemoveUserFromGroupOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.RemoveUserFromGroupWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ResetServiceSpecificCredential(ctx context.Context, input *iam.ResetServiceSpecificCredentialInput) (*iam.ResetServiceSpecificCredentialOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ResetServiceSpecificCredentialWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) ResyncMFADevice(ctx context.Context, input *iam.ResyncMFADeviceInput) (*iam.ResyncMFADeviceOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.ResyncMFADeviceWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) SetDefaultPolicyVersion(ctx context.Context, input *iam.SetDefaultPolicyVersionInput) (*iam.SetDefaultPolicyVersionOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.SetDefaultPolicyVersionWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) SetSecurityTokenServicePreferences(ctx context.Context, input *iam.SetSecurityTokenServicePreferencesInput) (*iam.SetSecurityTokenServicePreferencesOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.SetSecurityTokenServicePreferencesWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) SimulateCustomPolicy(ctx context.Context, input *iam.SimulateCustomPolicyInput) (*iam.SimulatePolicyResponse, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.SimulateCustomPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) SimulatePrincipalPolicy(ctx context.Context, input *iam.SimulatePrincipalPolicyInput) (*iam.SimulatePolicyResponse, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.SimulatePrincipalPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) TagRole(ctx context.Context, input *iam.TagRoleInput) (*iam.TagRoleOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.TagRoleWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) TagUser(ctx context.Context, input *iam.TagUserInput) (*iam.TagUserOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.TagUserWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UntagRole(ctx context.Context, input *iam.UntagRoleInput) (*iam.UntagRoleOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UntagRoleWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UntagUser(ctx context.Context, input *iam.UntagUserInput) (*iam.UntagUserOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UntagUserWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateAccessKey(ctx context.Context, input *iam.UpdateAccessKeyInput) (*iam.UpdateAccessKeyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateAccessKeyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateAccountPasswordPolicy(ctx context.Context, input *iam.UpdateAccountPasswordPolicyInput) (*iam.UpdateAccountPasswordPolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateAccountPasswordPolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateAssumeRolePolicy(ctx context.Context, input *iam.UpdateAssumeRolePolicyInput) (*iam.UpdateAssumeRolePolicyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateAssumeRolePolicyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateGroup(ctx context.Context, input *iam.UpdateGroupInput) (*iam.UpdateGroupOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateGroupWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateLoginProfile(ctx context.Context, input *iam.UpdateLoginProfileInput) (*iam.UpdateLoginProfileOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateLoginProfileWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateOpenIDConnectProviderThumbprint(ctx context.Context, input *iam.UpdateOpenIDConnectProviderThumbprintInput) (*iam.UpdateOpenIDConnectProviderThumbprintOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateOpenIDConnectProviderThumbprintWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateRole(ctx context.Context, input *iam.UpdateRoleInput) (*iam.UpdateRoleOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateRoleWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateRoleDescription(ctx context.Context, input *iam.UpdateRoleDescriptionInput) (*iam.UpdateRoleDescriptionOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateRoleDescriptionWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateSAMLProvider(ctx context.Context, input *iam.UpdateSAMLProviderInput) (*iam.UpdateSAMLProviderOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateSAMLProviderWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateSSHPublicKey(ctx context.Context, input *iam.UpdateSSHPublicKeyInput) (*iam.UpdateSSHPublicKeyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateSSHPublicKeyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateServerCertificate(ctx context.Context, input *iam.UpdateServerCertificateInput) (*iam.UpdateServerCertificateOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateServerCertificateWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateServiceSpecificCredential(ctx context.Context, input *iam.UpdateServiceSpecificCredentialInput) (*iam.UpdateServiceSpecificCredentialOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateServiceSpecificCredentialWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateSigningCertificate(ctx context.Context, input *iam.UpdateSigningCertificateInput) (*iam.UpdateSigningCertificateOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateSigningCertificateWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UpdateUser(ctx context.Context, input *iam.UpdateUserInput) (*iam.UpdateUserOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UpdateUserWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UploadSSHPublicKey(ctx context.Context, input *iam.UploadSSHPublicKeyInput) (*iam.UploadSSHPublicKeyOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UploadSSHPublicKeyWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UploadServerCertificate(ctx context.Context, input *iam.UploadServerCertificateInput) (*iam.UploadServerCertificateOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UploadServerCertificateWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) UploadSigningCertificate(ctx context.Context, input *iam.UploadSigningCertificateInput) (*iam.UploadSigningCertificateOutput, error) {
	client, err := a.getClient(ctx)
	if err != nil {
		return nil, internal.EncodeError(err)
	}
	output, err := client.UploadSigningCertificateWithContext(ctx, input)

	return output, internal.EncodeError(err)
}

func (a *Activities) WaitUntilInstanceProfileExists(ctx context.Context, input *iam.GetInstanceProfileInput) error {
	client, err := a.getClient(ctx)
	if err != nil {
		return internal.EncodeError(err)
	}
	return internal.WaitUntilActivity(ctx, func(ctx context.Context, options ...request.WaiterOption) error {
		return internal.EncodeError(client.WaitUntilInstanceProfileExistsWithContext(ctx, input, options...))
	})
}

func (a *Activities) WaitUntilPolicyExists(ctx context.Context, input *iam.GetPolicyInput) error {
	client, err := a.getClient(ctx)
	if err != nil {
		return internal.EncodeError(err)
	}
	return internal.WaitUntilActivity(ctx, func(ctx context.Context, options ...request.WaiterOption) error {
		return internal.EncodeError(client.WaitUntilPolicyExistsWithContext(ctx, input, options...))
	})
}

func (a *Activities) WaitUntilRoleExists(ctx context.Context, input *iam.GetRoleInput) error {
	client, err := a.getClient(ctx)
	if err != nil {
		return internal.EncodeError(err)
	}
	return internal.WaitUntilActivity(ctx, func(ctx context.Context, options ...request.WaiterOption) error {
		return internal.EncodeError(client.WaitUntilRoleExistsWithContext(ctx, input, options...))
	})
}

func (a *Activities) WaitUntilUserExists(ctx context.Context, input *iam.GetUserInput) error {
	client, err := a.getClient(ctx)
	if err != nil {
		return internal.EncodeError(err)
	}
	return internal.WaitUntilActivity(ctx, func(ctx context.Context, options ...request.WaiterOption) error {
		return internal.EncodeError(client.WaitUntilUserExistsWithContext(ctx, input, options...))
	})
}