iam

package

v0.4.0 Latest Latest Go to latest Published: Apr 15, 2024 License: Apache-2.0 Imports: 9 Imported by: 1

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/KscSDK/ksc-sdk-go

Links

Open Source Insights

Documentation ¶

Constants ¶

View Source

const (
	ServiceName = "iam"       // Name of service.
	EndpointsID = ServiceName // ID to lookup a service endpoint with.
	ServiceID   = "iam"       // ServiceID is a unique identifer of a specific service.
)

Service information constants

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type Iam ¶

type Iam struct {
	*client.Client
}

Iam provides the API operation methods for making requests to iam. See this package's package overview docs for details on the service.

Iam methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

func ExtraNew ¶

func ExtraNew(info *utils.UrlInfo, p client.ConfigProvider, cfgs ...*aws.Config) *Iam

extraNew create int can support ssl or region locate set

func New ¶

func New(p client.ConfigProvider, cfgs ...*aws.Config) *Iam

New creates a new instance of the Iam client with a session. If additional configuration is needed for the client instance use the optional ksc.Config parameter to add your extra config.

Example:

// Create a Iam client from just a session.
svc := iam.New(mySession)

// Create a Iam client with additional configuration
svc := iam.New(mySession, aws.NewConfig().WithRegion("us-west-2"))

func SdkNew ¶

func SdkNew(p client.ConfigProvider, cfgs *ksc.Config, info ...*utils.UrlInfo) *Iam

SdkNew create int can support ssl or region locate set

func (*Iam) AccountListRoles ¶

func (c *Iam) AccountListRoles(input *map[string]interface{}) (*map[string]interface{}, error)

AccountListRoles API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation AccountListRoles for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AccountListRoles

func (*Iam) AccountListRolesRequest ¶

func (c *Iam) AccountListRolesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AccountListRolesRequest generates a "ksc/request.Request" representing the client's request for the AccountListRoles operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AccountListRoles for more information on using the AccountListRoles API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AccountListRolesRequest method.
req, resp := client.AccountListRolesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) AccountListRolesWithContext ¶

func (c *Iam) AccountListRolesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AccountListRolesWithContext is the same as AccountListRoles with the addition of the ability to pass a context and additional request options.

See AccountListRoles for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) AddProjectMember ¶

func (c *Iam) AddProjectMember(input *map[string]interface{}) (*map[string]interface{}, error)

AddProjectMember API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation AddProjectMember for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AddProjectMember

func (*Iam) AddProjectMemberRequest ¶

func (c *Iam) AddProjectMemberRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AddProjectMemberRequest generates a "ksc/request.Request" representing the client's request for the AddProjectMember operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AddProjectMember for more information on using the AddProjectMember API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AddProjectMemberRequest method.
req, resp := client.AddProjectMemberRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) AddProjectMemberWithContext ¶

func (c *Iam) AddProjectMemberWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AddProjectMemberWithContext is the same as AddProjectMember with the addition of the ability to pass a context and additional request options.

See AddProjectMember for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) AddUserToGroup ¶

func (c *Iam) AddUserToGroup(input *map[string]interface{}) (*map[string]interface{}, error)

AddUserToGroup API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation AddUserToGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AddUserToGroup

func (*Iam) AddUserToGroupRequest ¶

func (c *Iam) AddUserToGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AddUserToGroupRequest generates a "ksc/request.Request" representing the client's request for the AddUserToGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AddUserToGroup for more information on using the AddUserToGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AddUserToGroupRequest method.
req, resp := client.AddUserToGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) AddUserToGroupWithContext ¶

func (c *Iam) AddUserToGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AddUserToGroupWithContext is the same as AddUserToGroup with the addition of the ability to pass a context and additional request options.

See AddUserToGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) AttachGroupPolicy ¶

func (c *Iam) AttachGroupPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

AttachGroupPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation AttachGroupPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AttachGroupPolicy

func (*Iam) AttachGroupPolicyRequest ¶

func (c *Iam) AttachGroupPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AttachGroupPolicyRequest generates a "ksc/request.Request" representing the client's request for the AttachGroupPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AttachGroupPolicy for more information on using the AttachGroupPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AttachGroupPolicyRequest method.
req, resp := client.AttachGroupPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) AttachGroupPolicyWithContext ¶

func (c *Iam) AttachGroupPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AttachGroupPolicyWithContext is the same as AttachGroupPolicy with the addition of the ability to pass a context and additional request options.

See AttachGroupPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) AttachRolePolicy ¶

func (c *Iam) AttachRolePolicy(input *map[string]interface{}) (*map[string]interface{}, error)

AttachRolePolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation AttachRolePolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AttachRolePolicy

func (*Iam) AttachRolePolicyRequest ¶

func (c *Iam) AttachRolePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AttachRolePolicyRequest generates a "ksc/request.Request" representing the client's request for the AttachRolePolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AttachRolePolicy for more information on using the AttachRolePolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AttachRolePolicyRequest method.
req, resp := client.AttachRolePolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) AttachRolePolicyWithContext ¶

func (c *Iam) AttachRolePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AttachRolePolicyWithContext is the same as AttachRolePolicy with the addition of the ability to pass a context and additional request options.

See AttachRolePolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) AttachUserPolicy ¶

func (c *Iam) AttachUserPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

AttachUserPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation AttachUserPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/AttachUserPolicy

func (*Iam) AttachUserPolicyRequest ¶

func (c *Iam) AttachUserPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

AttachUserPolicyRequest generates a "ksc/request.Request" representing the client's request for the AttachUserPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See AttachUserPolicy for more information on using the AttachUserPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the AttachUserPolicyRequest method.
req, resp := client.AttachUserPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) AttachUserPolicyWithContext ¶

func (c *Iam) AttachUserPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

AttachUserPolicyWithContext is the same as AttachUserPolicy with the addition of the ability to pass a context and additional request options.

See AttachUserPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) BatchGetInstanceProjectInfo ¶

func (c *Iam) BatchGetInstanceProjectInfo(input *map[string]interface{}) (*map[string]interface{}, error)

BatchGetInstanceProjectInfo API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation BatchGetInstanceProjectInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/BatchGetInstanceProjectInfo

func (*Iam) BatchGetInstanceProjectInfoRequest ¶

func (c *Iam) BatchGetInstanceProjectInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

BatchGetInstanceProjectInfoRequest generates a "ksc/request.Request" representing the client's request for the BatchGetInstanceProjectInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See BatchGetInstanceProjectInfo for more information on using the BatchGetInstanceProjectInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the BatchGetInstanceProjectInfoRequest method.
req, resp := client.BatchGetInstanceProjectInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) BatchGetInstanceProjectInfoWithContext ¶

func (c *Iam) BatchGetInstanceProjectInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

BatchGetInstanceProjectInfoWithContext is the same as BatchGetInstanceProjectInfo with the addition of the ability to pass a context and additional request options.

See BatchGetInstanceProjectInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) BatchGetProjectInfo ¶

func (c *Iam) BatchGetProjectInfo(input *map[string]interface{}) (*map[string]interface{}, error)

BatchGetProjectInfo API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation BatchGetProjectInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/BatchGetProjectInfo

func (*Iam) BatchGetProjectInfoRequest ¶

func (c *Iam) BatchGetProjectInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

BatchGetProjectInfoRequest generates a "ksc/request.Request" representing the client's request for the BatchGetProjectInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See BatchGetProjectInfo for more information on using the BatchGetProjectInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the BatchGetProjectInfoRequest method.
req, resp := client.BatchGetProjectInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) BatchGetProjectInfoWithContext ¶

func (c *Iam) BatchGetProjectInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

BatchGetProjectInfoWithContext is the same as BatchGetProjectInfo with the addition of the ability to pass a context and additional request options.

See BatchGetProjectInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ChangePassword ¶

func (c *Iam) ChangePassword(input *map[string]interface{}) (*map[string]interface{}, error)

ChangePassword API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ChangePassword for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ChangePassword

func (*Iam) ChangePasswordRequest ¶

func (c *Iam) ChangePasswordRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ChangePasswordRequest generates a "ksc/request.Request" representing the client's request for the ChangePassword operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ChangePassword for more information on using the ChangePassword API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ChangePasswordRequest method.
req, resp := client.ChangePasswordRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ChangePasswordWithContext ¶

func (c *Iam) ChangePasswordWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ChangePasswordWithContext is the same as ChangePassword with the addition of the ability to pass a context and additional request options.

See ChangePassword for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CheckUserEnableMFA ¶

func (c *Iam) CheckUserEnableMFA(input *map[string]interface{}) (*map[string]interface{}, error)

CheckUserEnableMFA API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CheckUserEnableMFA for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CheckUserEnableMFA

func (*Iam) CheckUserEnableMFARequest ¶

func (c *Iam) CheckUserEnableMFARequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CheckUserEnableMFARequest generates a "ksc/request.Request" representing the client's request for the CheckUserEnableMFA operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CheckUserEnableMFA for more information on using the CheckUserEnableMFA API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CheckUserEnableMFARequest method.
req, resp := client.CheckUserEnableMFARequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) CheckUserEnableMFAWithContext ¶

func (c *Iam) CheckUserEnableMFAWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CheckUserEnableMFAWithContext is the same as CheckUserEnableMFA with the addition of the ability to pass a context and additional request options.

See CheckUserEnableMFA for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CheckUserSessionCode ¶

func (c *Iam) CheckUserSessionCode(input *map[string]interface{}) (*map[string]interface{}, error)

CheckUserSessionCode API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CheckUserSessionCode for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CheckUserSessionCode

func (*Iam) CheckUserSessionCodeRequest ¶

func (c *Iam) CheckUserSessionCodeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CheckUserSessionCodeRequest generates a "ksc/request.Request" representing the client's request for the CheckUserSessionCode operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CheckUserSessionCode for more information on using the CheckUserSessionCode API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CheckUserSessionCodeRequest method.
req, resp := client.CheckUserSessionCodeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) CheckUserSessionCodeWithContext ¶

func (c *Iam) CheckUserSessionCodeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CheckUserSessionCodeWithContext is the same as CheckUserSessionCode with the addition of the ability to pass a context and additional request options.

See CheckUserSessionCode for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateAccessKey ¶

func (c *Iam) CreateAccessKey(input *map[string]interface{}) (*map[string]interface{}, error)

CreateAccessKey API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateAccessKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateAccessKey

func (*Iam) CreateAccessKeyRequest ¶

func (c *Iam) CreateAccessKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateAccessKeyRequest generates a "ksc/request.Request" representing the client's request for the CreateAccessKey operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateAccessKey for more information on using the CreateAccessKey API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateAccessKeyRequest method.
req, resp := client.CreateAccessKeyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) CreateAccessKeyWithContext ¶

func (c *Iam) CreateAccessKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateAccessKeyWithContext is the same as CreateAccessKey with the addition of the ability to pass a context and additional request options.

See CreateAccessKey for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateAccount ¶

func (c *Iam) CreateAccount(input *map[string]interface{}) (*map[string]interface{}, error)

CreateAccount API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateAccount for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateAccount

func (*Iam) CreateAccountRequest ¶

func (c *Iam) CreateAccountRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateAccountRequest generates a "ksc/request.Request" representing the client's request for the CreateAccount operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateAccount for more information on using the CreateAccount API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateAccountRequest method.
req, resp := client.CreateAccountRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) CreateAccountWithContext ¶

func (c *Iam) CreateAccountWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateAccountWithContext is the same as CreateAccount with the addition of the ability to pass a context and additional request options.

See CreateAccount for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateGroup ¶

func (c *Iam) CreateGroup(input *map[string]interface{}) (*map[string]interface{}, error)

CreateGroup API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateGroup

func (*Iam) CreateGroupRequest ¶

func (c *Iam) CreateGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateGroupRequest generates a "ksc/request.Request" representing the client's request for the CreateGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateGroup for more information on using the CreateGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateGroupRequest method.
req, resp := client.CreateGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) CreateGroupWithContext ¶

func (c *Iam) CreateGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateGroupWithContext is the same as CreateGroup with the addition of the ability to pass a context and additional request options.

See CreateGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateLoginProfile ¶

func (c *Iam) CreateLoginProfile(input *map[string]interface{}) (*map[string]interface{}, error)

CreateLoginProfile API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateLoginProfile for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateLoginProfile

func (*Iam) CreateLoginProfileRequest ¶

func (c *Iam) CreateLoginProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateLoginProfileRequest generates a "ksc/request.Request" representing the client's request for the CreateLoginProfile operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateLoginProfile for more information on using the CreateLoginProfile API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateLoginProfileRequest method.
req, resp := client.CreateLoginProfileRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) CreateLoginProfileWithContext ¶

func (c *Iam) CreateLoginProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateLoginProfileWithContext is the same as CreateLoginProfile with the addition of the ability to pass a context and additional request options.

See CreateLoginProfile for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreatePolicy ¶

func (c *Iam) CreatePolicy(input *map[string]interface{}) (*map[string]interface{}, error)

CreatePolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreatePolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreatePolicy

func (*Iam) CreatePolicyRequest ¶

func (c *Iam) CreatePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreatePolicyRequest generates a "ksc/request.Request" representing the client's request for the CreatePolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreatePolicy for more information on using the CreatePolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreatePolicyRequest method.
req, resp := client.CreatePolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) CreatePolicyVersion ¶

func (c *Iam) CreatePolicyVersion(input *map[string]interface{}) (*map[string]interface{}, error)

CreatePolicyVersion API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreatePolicyVersion for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreatePolicyVersion

func (*Iam) CreatePolicyVersionRequest ¶

func (c *Iam) CreatePolicyVersionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreatePolicyVersionRequest generates a "ksc/request.Request" representing the client's request for the CreatePolicyVersion operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreatePolicyVersion for more information on using the CreatePolicyVersion API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreatePolicyVersionRequest method.
req, resp := client.CreatePolicyVersionRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) CreatePolicyVersionWithContext ¶

func (c *Iam) CreatePolicyVersionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreatePolicyVersionWithContext is the same as CreatePolicyVersion with the addition of the ability to pass a context and additional request options.

See CreatePolicyVersion for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreatePolicyWithContext ¶

func (c *Iam) CreatePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreatePolicyWithContext is the same as CreatePolicy with the addition of the ability to pass a context and additional request options.

See CreatePolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateProject ¶

func (c *Iam) CreateProject(input *map[string]interface{}) (*map[string]interface{}, error)

CreateProject API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateProject for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateProject

func (*Iam) CreateProjectRequest ¶

func (c *Iam) CreateProjectRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateProjectRequest generates a "ksc/request.Request" representing the client's request for the CreateProject operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateProject for more information on using the CreateProject API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateProjectRequest method.
req, resp := client.CreateProjectRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) CreateProjectWithContext ¶

func (c *Iam) CreateProjectWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateProjectWithContext is the same as CreateProject with the addition of the ability to pass a context and additional request options.

See CreateProject for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateRole ¶

func (c *Iam) CreateRole(input *map[string]interface{}) (*map[string]interface{}, error)

CreateRole API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateRole for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateRole

func (*Iam) CreateRoleRequest ¶

func (c *Iam) CreateRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateRoleRequest generates a "ksc/request.Request" representing the client's request for the CreateRole operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateRole for more information on using the CreateRole API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateRoleRequest method.
req, resp := client.CreateRoleRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) CreateRoleWithContext ¶

func (c *Iam) CreateRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateRoleWithContext is the same as CreateRole with the addition of the ability to pass a context and additional request options.

See CreateRole for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateUser ¶

func (c *Iam) CreateUser(input *map[string]interface{}) (*map[string]interface{}, error)

CreateUser API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateUser for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateUser

func (*Iam) CreateUserRequest ¶

func (c *Iam) CreateUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateUserRequest generates a "ksc/request.Request" representing the client's request for the CreateUser operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateUser for more information on using the CreateUser API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateUserRequest method.
req, resp := client.CreateUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) CreateUserWithContext ¶

func (c *Iam) CreateUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateUserWithContext is the same as CreateUser with the addition of the ability to pass a context and additional request options.

See CreateUser for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) CreateVirtualMFADevice ¶

func (c *Iam) CreateVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

CreateVirtualMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation CreateVirtualMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/CreateVirtualMFADevice

func (*Iam) CreateVirtualMFADeviceRequest ¶

func (c *Iam) CreateVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

CreateVirtualMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the CreateVirtualMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See CreateVirtualMFADevice for more information on using the CreateVirtualMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the CreateVirtualMFADeviceRequest method.
req, resp := client.CreateVirtualMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) CreateVirtualMFADeviceWithContext ¶

func (c *Iam) CreateVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

CreateVirtualMFADeviceWithContext is the same as CreateVirtualMFADevice with the addition of the ability to pass a context and additional request options.

See CreateVirtualMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeactivateAccountMFADevice ¶

func (c *Iam) DeactivateAccountMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

DeactivateAccountMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeactivateAccountMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeactivateAccountMFADevice

func (*Iam) DeactivateAccountMFADeviceRequest ¶

func (c *Iam) DeactivateAccountMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeactivateAccountMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the DeactivateAccountMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeactivateAccountMFADevice for more information on using the DeactivateAccountMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeactivateAccountMFADeviceRequest method.
req, resp := client.DeactivateAccountMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DeactivateAccountMFADeviceWithContext ¶

func (c *Iam) DeactivateAccountMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeactivateAccountMFADeviceWithContext is the same as DeactivateAccountMFADevice with the addition of the ability to pass a context and additional request options.

See DeactivateAccountMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeactivateMFADevice ¶

func (c *Iam) DeactivateMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

DeactivateMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeactivateMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeactivateMFADevice

func (*Iam) DeactivateMFADeviceRequest ¶

func (c *Iam) DeactivateMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeactivateMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the DeactivateMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeactivateMFADevice for more information on using the DeactivateMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeactivateMFADeviceRequest method.
req, resp := client.DeactivateMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DeactivateMFADeviceWithContext ¶

func (c *Iam) DeactivateMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeactivateMFADeviceWithContext is the same as DeactivateMFADevice with the addition of the ability to pass a context and additional request options.

See DeactivateMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteAccessKey ¶

func (c *Iam) DeleteAccessKey(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteAccessKey API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteAccessKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteAccessKey

func (*Iam) DeleteAccessKeyRequest ¶

func (c *Iam) DeleteAccessKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteAccessKeyRequest generates a "ksc/request.Request" representing the client's request for the DeleteAccessKey operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteAccessKey for more information on using the DeleteAccessKey API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteAccessKeyRequest method.
req, resp := client.DeleteAccessKeyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DeleteAccessKeyWithContext ¶

func (c *Iam) DeleteAccessKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteAccessKeyWithContext is the same as DeleteAccessKey with the addition of the ability to pass a context and additional request options.

See DeleteAccessKey for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteGroup ¶

func (c *Iam) DeleteGroup(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteGroup API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteGroup

func (*Iam) DeleteGroupRequest ¶

func (c *Iam) DeleteGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteGroupRequest generates a "ksc/request.Request" representing the client's request for the DeleteGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteGroup for more information on using the DeleteGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteGroupRequest method.
req, resp := client.DeleteGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DeleteGroupWithContext ¶

func (c *Iam) DeleteGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteGroupWithContext is the same as DeleteGroup with the addition of the ability to pass a context and additional request options.

See DeleteGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteIdentityAndProjectRelation ¶

func (c *Iam) DeleteIdentityAndProjectRelation(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteIdentityAndProjectRelation API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteIdentityAndProjectRelation for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteIdentityAndProjectRelation

func (*Iam) DeleteIdentityAndProjectRelationRequest ¶

func (c *Iam) DeleteIdentityAndProjectRelationRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteIdentityAndProjectRelationRequest generates a "ksc/request.Request" representing the client's request for the DeleteIdentityAndProjectRelation operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteIdentityAndProjectRelation for more information on using the DeleteIdentityAndProjectRelation API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteIdentityAndProjectRelationRequest method.
req, resp := client.DeleteIdentityAndProjectRelationRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DeleteIdentityAndProjectRelationWithContext ¶

func (c *Iam) DeleteIdentityAndProjectRelationWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteIdentityAndProjectRelationWithContext is the same as DeleteIdentityAndProjectRelation with the addition of the ability to pass a context and additional request options.

See DeleteIdentityAndProjectRelation for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteLoginProfile ¶

func (c *Iam) DeleteLoginProfile(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteLoginProfile API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteLoginProfile for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteLoginProfile

func (*Iam) DeleteLoginProfileRequest ¶

func (c *Iam) DeleteLoginProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteLoginProfileRequest generates a "ksc/request.Request" representing the client's request for the DeleteLoginProfile operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteLoginProfile for more information on using the DeleteLoginProfile API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteLoginProfileRequest method.
req, resp := client.DeleteLoginProfileRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DeleteLoginProfileWithContext ¶

func (c *Iam) DeleteLoginProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteLoginProfileWithContext is the same as DeleteLoginProfile with the addition of the ability to pass a context and additional request options.

See DeleteLoginProfile for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeletePolicy ¶

func (c *Iam) DeletePolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DeletePolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeletePolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeletePolicy

func (*Iam) DeletePolicyRequest ¶

func (c *Iam) DeletePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeletePolicyRequest generates a "ksc/request.Request" representing the client's request for the DeletePolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeletePolicy for more information on using the DeletePolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeletePolicyRequest method.
req, resp := client.DeletePolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DeletePolicyVersion ¶

func (c *Iam) DeletePolicyVersion(input *map[string]interface{}) (*map[string]interface{}, error)

DeletePolicyVersion API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeletePolicyVersion for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeletePolicyVersion

func (*Iam) DeletePolicyVersionRequest ¶

func (c *Iam) DeletePolicyVersionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeletePolicyVersionRequest generates a "ksc/request.Request" representing the client's request for the DeletePolicyVersion operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeletePolicyVersion for more information on using the DeletePolicyVersion API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeletePolicyVersionRequest method.
req, resp := client.DeletePolicyVersionRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DeletePolicyVersionWithContext ¶

func (c *Iam) DeletePolicyVersionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeletePolicyVersionWithContext is the same as DeletePolicyVersion with the addition of the ability to pass a context and additional request options.

See DeletePolicyVersion for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeletePolicyWithContext ¶

func (c *Iam) DeletePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeletePolicyWithContext is the same as DeletePolicy with the addition of the ability to pass a context and additional request options.

See DeletePolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteProjectMember ¶

func (c *Iam) DeleteProjectMember(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteProjectMember API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteProjectMember for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteProjectMember

func (*Iam) DeleteProjectMemberRequest ¶

func (c *Iam) DeleteProjectMemberRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteProjectMemberRequest generates a "ksc/request.Request" representing the client's request for the DeleteProjectMember operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteProjectMember for more information on using the DeleteProjectMember API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteProjectMemberRequest method.
req, resp := client.DeleteProjectMemberRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DeleteProjectMemberWithContext ¶

func (c *Iam) DeleteProjectMemberWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteProjectMemberWithContext is the same as DeleteProjectMember with the addition of the ability to pass a context and additional request options.

See DeleteProjectMember for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteRole ¶

func (c *Iam) DeleteRole(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteRole API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteRole for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteRole

func (*Iam) DeleteRoleRequest ¶

func (c *Iam) DeleteRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteRoleRequest generates a "ksc/request.Request" representing the client's request for the DeleteRole operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteRole for more information on using the DeleteRole API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteRoleRequest method.
req, resp := client.DeleteRoleRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DeleteRoleWithContext ¶

func (c *Iam) DeleteRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteRoleWithContext is the same as DeleteRole with the addition of the ability to pass a context and additional request options.

See DeleteRole for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteUser ¶

func (c *Iam) DeleteUser(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteUser API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteUser for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteUser

func (*Iam) DeleteUserRequest ¶

func (c *Iam) DeleteUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteUserRequest generates a "ksc/request.Request" representing the client's request for the DeleteUser operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteUser for more information on using the DeleteUser API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteUserRequest method.
req, resp := client.DeleteUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DeleteUserWithContext ¶

func (c *Iam) DeleteUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteUserWithContext is the same as DeleteUser with the addition of the ability to pass a context and additional request options.

See DeleteUser for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DeleteVirtualMFADevice ¶

func (c *Iam) DeleteVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

DeleteVirtualMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DeleteVirtualMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DeleteVirtualMFADevice

func (*Iam) DeleteVirtualMFADeviceRequest ¶

func (c *Iam) DeleteVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DeleteVirtualMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the DeleteVirtualMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DeleteVirtualMFADevice for more information on using the DeleteVirtualMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DeleteVirtualMFADeviceRequest method.
req, resp := client.DeleteVirtualMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DeleteVirtualMFADeviceWithContext ¶

func (c *Iam) DeleteVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DeleteVirtualMFADeviceWithContext is the same as DeleteVirtualMFADevice with the addition of the ability to pass a context and additional request options.

See DeleteVirtualMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DetachGroupPolicy ¶

func (c *Iam) DetachGroupPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DetachGroupPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DetachGroupPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DetachGroupPolicy

func (*Iam) DetachGroupPolicyRequest ¶

func (c *Iam) DetachGroupPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DetachGroupPolicyRequest generates a "ksc/request.Request" representing the client's request for the DetachGroupPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DetachGroupPolicy for more information on using the DetachGroupPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DetachGroupPolicyRequest method.
req, resp := client.DetachGroupPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DetachGroupPolicyWithContext ¶

func (c *Iam) DetachGroupPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DetachGroupPolicyWithContext is the same as DetachGroupPolicy with the addition of the ability to pass a context and additional request options.

See DetachGroupPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DetachRolePolicy ¶

func (c *Iam) DetachRolePolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DetachRolePolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DetachRolePolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DetachRolePolicy

func (*Iam) DetachRolePolicyRequest ¶

func (c *Iam) DetachRolePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DetachRolePolicyRequest generates a "ksc/request.Request" representing the client's request for the DetachRolePolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DetachRolePolicy for more information on using the DetachRolePolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DetachRolePolicyRequest method.
req, resp := client.DetachRolePolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DetachRolePolicyWithContext ¶

func (c *Iam) DetachRolePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DetachRolePolicyWithContext is the same as DetachRolePolicy with the addition of the ability to pass a context and additional request options.

See DetachRolePolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) DetachUserPolicy ¶

func (c *Iam) DetachUserPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

DetachUserPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation DetachUserPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/DetachUserPolicy

func (*Iam) DetachUserPolicyRequest ¶

func (c *Iam) DetachUserPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

DetachUserPolicyRequest generates a "ksc/request.Request" representing the client's request for the DetachUserPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See DetachUserPolicy for more information on using the DetachUserPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the DetachUserPolicyRequest method.
req, resp := client.DetachUserPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) DetachUserPolicyWithContext ¶

func (c *Iam) DetachUserPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

DetachUserPolicyWithContext is the same as DetachUserPolicy with the addition of the ability to pass a context and additional request options.

See DetachUserPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) EnableAccountMFADevice ¶

func (c *Iam) EnableAccountMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

EnableAccountMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation EnableAccountMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/EnableAccountMFADevice

func (*Iam) EnableAccountMFADeviceRequest ¶

func (c *Iam) EnableAccountMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

EnableAccountMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the EnableAccountMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See EnableAccountMFADevice for more information on using the EnableAccountMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the EnableAccountMFADeviceRequest method.
req, resp := client.EnableAccountMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) EnableAccountMFADeviceWithContext ¶

func (c *Iam) EnableAccountMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

EnableAccountMFADeviceWithContext is the same as EnableAccountMFADevice with the addition of the ability to pass a context and additional request options.

See EnableAccountMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) EnableMFADevice ¶

func (c *Iam) EnableMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

EnableMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation EnableMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/EnableMFADevice

func (*Iam) EnableMFADeviceRequest ¶

func (c *Iam) EnableMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

EnableMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the EnableMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See EnableMFADevice for more information on using the EnableMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the EnableMFADeviceRequest method.
req, resp := client.EnableMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) EnableMFADeviceWithContext ¶

func (c *Iam) EnableMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

EnableMFADeviceWithContext is the same as EnableMFADevice with the addition of the ability to pass a context and additional request options.

See EnableMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) EnableMfaProfile ¶

func (c *Iam) EnableMfaProfile(input *map[string]interface{}) (*map[string]interface{}, error)

EnableMfaProfile API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation EnableMfaProfile for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/EnableMfaProfile

func (*Iam) EnableMfaProfileRequest ¶

func (c *Iam) EnableMfaProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

EnableMfaProfileRequest generates a "ksc/request.Request" representing the client's request for the EnableMfaProfile operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See EnableMfaProfile for more information on using the EnableMfaProfile API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the EnableMfaProfileRequest method.
req, resp := client.EnableMfaProfileRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) EnableMfaProfileWithContext ¶

func (c *Iam) EnableMfaProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

EnableMfaProfileWithContext is the same as EnableMfaProfile with the addition of the ability to pass a context and additional request options.

See EnableMfaProfile for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetAccountAllProjectList ¶

func (c *Iam) GetAccountAllProjectList(input *map[string]interface{}) (*map[string]interface{}, error)

GetAccountAllProjectList API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetAccountAllProjectList for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountAllProjectList

func (*Iam) GetAccountAllProjectListRequest ¶

func (c *Iam) GetAccountAllProjectListRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetAccountAllProjectListRequest generates a "ksc/request.Request" representing the client's request for the GetAccountAllProjectList operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetAccountAllProjectList for more information on using the GetAccountAllProjectList API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetAccountAllProjectListRequest method.
req, resp := client.GetAccountAllProjectListRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetAccountAllProjectListWithContext ¶

func (c *Iam) GetAccountAllProjectListWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetAccountAllProjectListWithContext is the same as GetAccountAllProjectList with the addition of the ability to pass a context and additional request options.

See GetAccountAllProjectList for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetAccountProjectInfo ¶

func (c *Iam) GetAccountProjectInfo(input *map[string]interface{}) (*map[string]interface{}, error)

GetAccountProjectInfo API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetAccountProjectInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountProjectInfo

func (*Iam) GetAccountProjectInfoRequest ¶

func (c *Iam) GetAccountProjectInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetAccountProjectInfoRequest generates a "ksc/request.Request" representing the client's request for the GetAccountProjectInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetAccountProjectInfo for more information on using the GetAccountProjectInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetAccountProjectInfoRequest method.
req, resp := client.GetAccountProjectInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetAccountProjectInfoWithContext ¶

func (c *Iam) GetAccountProjectInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetAccountProjectInfoWithContext is the same as GetAccountProjectInfo with the addition of the ability to pass a context and additional request options.

See GetAccountProjectInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetAccountProjectList ¶

func (c *Iam) GetAccountProjectList(input *map[string]interface{}) (*map[string]interface{}, error)

GetAccountProjectList API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetAccountProjectList for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountProjectList

func (*Iam) GetAccountProjectListRequest ¶

func (c *Iam) GetAccountProjectListRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetAccountProjectListRequest generates a "ksc/request.Request" representing the client's request for the GetAccountProjectList operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetAccountProjectList for more information on using the GetAccountProjectList API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetAccountProjectListRequest method.
req, resp := client.GetAccountProjectListRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetAccountProjectListWithContext ¶

func (c *Iam) GetAccountProjectListWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetAccountProjectListWithContext is the same as GetAccountProjectList with the addition of the ability to pass a context and additional request options.

See GetAccountProjectList for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetAccountProjectTotal ¶

func (c *Iam) GetAccountProjectTotal(input *map[string]interface{}) (*map[string]interface{}, error)

GetAccountProjectTotal API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetAccountProjectTotal for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountProjectTotal

func (*Iam) GetAccountProjectTotalRequest ¶

func (c *Iam) GetAccountProjectTotalRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetAccountProjectTotalRequest generates a "ksc/request.Request" representing the client's request for the GetAccountProjectTotal operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetAccountProjectTotal for more information on using the GetAccountProjectTotal API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetAccountProjectTotalRequest method.
req, resp := client.GetAccountProjectTotalRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetAccountProjectTotalWithContext ¶

func (c *Iam) GetAccountProjectTotalWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetAccountProjectTotalWithContext is the same as GetAccountProjectTotal with the addition of the ability to pass a context and additional request options.

See GetAccountProjectTotal for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetAccountSummary ¶

func (c *Iam) GetAccountSummary(input *map[string]interface{}) (*map[string]interface{}, error)

GetAccountSummary API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetAccountSummary for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetAccountSummary

func (*Iam) GetAccountSummaryRequest ¶

func (c *Iam) GetAccountSummaryRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetAccountSummaryRequest generates a "ksc/request.Request" representing the client's request for the GetAccountSummary operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetAccountSummary for more information on using the GetAccountSummary API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetAccountSummaryRequest method.
req, resp := client.GetAccountSummaryRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetAccountSummaryWithContext ¶

func (c *Iam) GetAccountSummaryWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetAccountSummaryWithContext is the same as GetAccountSummary with the addition of the ability to pass a context and additional request options.

See GetAccountSummary for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetGroup ¶

func (c *Iam) GetGroup(input *map[string]interface{}) (*map[string]interface{}, error)

GetGroup API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetGroup

func (*Iam) GetGroupRequest ¶

func (c *Iam) GetGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetGroupRequest generates a "ksc/request.Request" representing the client's request for the GetGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetGroup for more information on using the GetGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetGroupRequest method.
req, resp := client.GetGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetGroupWithContext ¶

func (c *Iam) GetGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetGroupWithContext is the same as GetGroup with the addition of the ability to pass a context and additional request options.

See GetGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetLoginProfile ¶

func (c *Iam) GetLoginProfile(input *map[string]interface{}) (*map[string]interface{}, error)

GetLoginProfile API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetLoginProfile for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetLoginProfile

func (*Iam) GetLoginProfileRequest ¶

func (c *Iam) GetLoginProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetLoginProfileRequest generates a "ksc/request.Request" representing the client's request for the GetLoginProfile operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetLoginProfile for more information on using the GetLoginProfile API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetLoginProfileRequest method.
req, resp := client.GetLoginProfileRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetLoginProfileWithContext ¶

func (c *Iam) GetLoginProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetLoginProfileWithContext is the same as GetLoginProfile with the addition of the ability to pass a context and additional request options.

See GetLoginProfile for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetMfaProfile ¶

func (c *Iam) GetMfaProfile(input *map[string]interface{}) (*map[string]interface{}, error)

GetMfaProfile API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetMfaProfile for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetMfaProfile

func (*Iam) GetMfaProfileRequest ¶

func (c *Iam) GetMfaProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetMfaProfileRequest generates a "ksc/request.Request" representing the client's request for the GetMfaProfile operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetMfaProfile for more information on using the GetMfaProfile API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetMfaProfileRequest method.
req, resp := client.GetMfaProfileRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetMfaProfileWithContext ¶

func (c *Iam) GetMfaProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetMfaProfileWithContext is the same as GetMfaProfile with the addition of the ability to pass a context and additional request options.

See GetMfaProfile for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetMiniProgramVirtualMFADevice ¶

func (c *Iam) GetMiniProgramVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

GetMiniProgramVirtualMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetMiniProgramVirtualMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetMiniProgramVirtualMFADevice

func (*Iam) GetMiniProgramVirtualMFADeviceRequest ¶

func (c *Iam) GetMiniProgramVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetMiniProgramVirtualMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the GetMiniProgramVirtualMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetMiniProgramVirtualMFADevice for more information on using the GetMiniProgramVirtualMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetMiniProgramVirtualMFADeviceRequest method.
req, resp := client.GetMiniProgramVirtualMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetMiniProgramVirtualMFADeviceWithContext ¶

func (c *Iam) GetMiniProgramVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetMiniProgramVirtualMFADeviceWithContext is the same as GetMiniProgramVirtualMFADevice with the addition of the ability to pass a context and additional request options.

See GetMiniProgramVirtualMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetPolicy ¶

func (c *Iam) GetPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

GetPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetPolicy

func (*Iam) GetPolicyRequest ¶

func (c *Iam) GetPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPolicyRequest generates a "ksc/request.Request" representing the client's request for the GetPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPolicy for more information on using the GetPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPolicyRequest method.
req, resp := client.GetPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetPolicyVersion ¶

func (c *Iam) GetPolicyVersion(input *map[string]interface{}) (*map[string]interface{}, error)

GetPolicyVersion API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetPolicyVersion for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetPolicyVersion

func (*Iam) GetPolicyVersionRequest ¶

func (c *Iam) GetPolicyVersionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPolicyVersionRequest generates a "ksc/request.Request" representing the client's request for the GetPolicyVersion operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPolicyVersion for more information on using the GetPolicyVersion API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPolicyVersionRequest method.
req, resp := client.GetPolicyVersionRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetPolicyVersionWithContext ¶

func (c *Iam) GetPolicyVersionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPolicyVersionWithContext is the same as GetPolicyVersion with the addition of the ability to pass a context and additional request options.

See GetPolicyVersion for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetPolicyWithContext ¶

func (c *Iam) GetPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPolicyWithContext is the same as GetPolicy with the addition of the ability to pass a context and additional request options.

See GetPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetProjectInstanceList ¶

func (c *Iam) GetProjectInstanceList(input *map[string]interface{}) (*map[string]interface{}, error)

GetProjectInstanceList API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetProjectInstanceList for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetProjectInstanceList

func (*Iam) GetProjectInstanceListRequest ¶

func (c *Iam) GetProjectInstanceListRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetProjectInstanceListRequest generates a "ksc/request.Request" representing the client's request for the GetProjectInstanceList operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetProjectInstanceList for more information on using the GetProjectInstanceList API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetProjectInstanceListRequest method.
req, resp := client.GetProjectInstanceListRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetProjectInstanceListWithContext ¶

func (c *Iam) GetProjectInstanceListWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetProjectInstanceListWithContext is the same as GetProjectInstanceList with the addition of the ability to pass a context and additional request options.

See GetProjectInstanceList for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetPwdPolicy ¶

func (c *Iam) GetPwdPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

GetPwdPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetPwdPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetPwdPolicy

func (*Iam) GetPwdPolicyRequest ¶

func (c *Iam) GetPwdPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetPwdPolicyRequest generates a "ksc/request.Request" representing the client's request for the GetPwdPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetPwdPolicy for more information on using the GetPwdPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetPwdPolicyRequest method.
req, resp := client.GetPwdPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetPwdPolicyWithContext ¶

func (c *Iam) GetPwdPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetPwdPolicyWithContext is the same as GetPwdPolicy with the addition of the ability to pass a context and additional request options.

See GetPwdPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetRole ¶

func (c *Iam) GetRole(input *map[string]interface{}) (*map[string]interface{}, error)

GetRole API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetRole for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetRole

func (*Iam) GetRoleRequest ¶

func (c *Iam) GetRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetRoleRequest generates a "ksc/request.Request" representing the client's request for the GetRole operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetRole for more information on using the GetRole API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetRoleRequest method.
req, resp := client.GetRoleRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetRoleWithContext ¶

func (c *Iam) GetRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetRoleWithContext is the same as GetRole with the addition of the ability to pass a context and additional request options.

See GetRole for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetUser ¶

func (c *Iam) GetUser(input *map[string]interface{}) (*map[string]interface{}, error)

GetUser API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetUser for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetUser

func (*Iam) GetUserLoginInfo ¶

func (c *Iam) GetUserLoginInfo(input *map[string]interface{}) (*map[string]interface{}, error)

GetUserLoginInfo API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetUserLoginInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetUserLoginInfo

func (*Iam) GetUserLoginInfoRequest ¶

func (c *Iam) GetUserLoginInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetUserLoginInfoRequest generates a "ksc/request.Request" representing the client's request for the GetUserLoginInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetUserLoginInfo for more information on using the GetUserLoginInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetUserLoginInfoRequest method.
req, resp := client.GetUserLoginInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetUserLoginInfoWithContext ¶

func (c *Iam) GetUserLoginInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetUserLoginInfoWithContext is the same as GetUserLoginInfo with the addition of the ability to pass a context and additional request options.

See GetUserLoginInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetUserRequest ¶

func (c *Iam) GetUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetUserRequest generates a "ksc/request.Request" representing the client's request for the GetUser operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetUser for more information on using the GetUser API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetUserRequest method.
req, resp := client.GetUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetUserSession ¶

func (c *Iam) GetUserSession(input *map[string]interface{}) (*map[string]interface{}, error)

GetUserSession API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetUserSession for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetUserSession

func (*Iam) GetUserSessionRequest ¶

func (c *Iam) GetUserSessionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetUserSessionRequest generates a "ksc/request.Request" representing the client's request for the GetUserSession operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetUserSession for more information on using the GetUserSession API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetUserSessionRequest method.
req, resp := client.GetUserSessionRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetUserSessionWithContext ¶

func (c *Iam) GetUserSessionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetUserSessionWithContext is the same as GetUserSession with the addition of the ability to pass a context and additional request options.

See GetUserSession for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetUserWithContext ¶

func (c *Iam) GetUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetUserWithContext is the same as GetUser with the addition of the ability to pass a context and additional request options.

See GetUser for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) GetVirtualMFADevice ¶

func (c *Iam) GetVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

GetVirtualMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation GetVirtualMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/GetVirtualMFADevice

func (*Iam) GetVirtualMFADeviceRequest ¶

func (c *Iam) GetVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

GetVirtualMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the GetVirtualMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See GetVirtualMFADevice for more information on using the GetVirtualMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the GetVirtualMFADeviceRequest method.
req, resp := client.GetVirtualMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) GetVirtualMFADeviceWithContext ¶

func (c *Iam) GetVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

GetVirtualMFADeviceWithContext is the same as GetVirtualMFADevice with the addition of the ability to pass a context and additional request options.

See GetVirtualMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListAccessKeys ¶

func (c *Iam) ListAccessKeys(input *map[string]interface{}) (*map[string]interface{}, error)

ListAccessKeys API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListAccessKeys for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListAccessKeys

func (*Iam) ListAccessKeysRequest ¶

func (c *Iam) ListAccessKeysRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListAccessKeysRequest generates a "ksc/request.Request" representing the client's request for the ListAccessKeys operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListAccessKeys for more information on using the ListAccessKeys API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListAccessKeysRequest method.
req, resp := client.ListAccessKeysRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListAccessKeysWithContext ¶

func (c *Iam) ListAccessKeysWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListAccessKeysWithContext is the same as ListAccessKeys with the addition of the ability to pass a context and additional request options.

See ListAccessKeys for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListApiLogTpl ¶

func (c *Iam) ListApiLogTpl(input *map[string]interface{}) (*map[string]interface{}, error)

ListApiLogTpl API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListApiLogTpl for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListApiLogTpl

func (*Iam) ListApiLogTplRequest ¶

func (c *Iam) ListApiLogTplRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListApiLogTplRequest generates a "ksc/request.Request" representing the client's request for the ListApiLogTpl operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListApiLogTpl for more information on using the ListApiLogTpl API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListApiLogTplRequest method.
req, resp := client.ListApiLogTplRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListApiLogTplWithContext ¶

func (c *Iam) ListApiLogTplWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListApiLogTplWithContext is the same as ListApiLogTpl with the addition of the ability to pass a context and additional request options.

See ListApiLogTpl for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListAttachedRolePolicies ¶

func (c *Iam) ListAttachedRolePolicies(input *map[string]interface{}) (*map[string]interface{}, error)

ListAttachedRolePolicies API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListAttachedRolePolicies for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListAttachedRolePolicies

func (*Iam) ListAttachedRolePoliciesRequest ¶

func (c *Iam) ListAttachedRolePoliciesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListAttachedRolePoliciesRequest generates a "ksc/request.Request" representing the client's request for the ListAttachedRolePolicies operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListAttachedRolePolicies for more information on using the ListAttachedRolePolicies API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListAttachedRolePoliciesRequest method.
req, resp := client.ListAttachedRolePoliciesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListAttachedRolePoliciesWithContext ¶

func (c *Iam) ListAttachedRolePoliciesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListAttachedRolePoliciesWithContext is the same as ListAttachedRolePolicies with the addition of the ability to pass a context and additional request options.

See ListAttachedRolePolicies for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListAttachedUserPolicies ¶

func (c *Iam) ListAttachedUserPolicies(input *map[string]interface{}) (*map[string]interface{}, error)

ListAttachedUserPolicies API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListAttachedUserPolicies for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListAttachedUserPolicies

func (*Iam) ListAttachedUserPoliciesRequest ¶

func (c *Iam) ListAttachedUserPoliciesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListAttachedUserPoliciesRequest generates a "ksc/request.Request" representing the client's request for the ListAttachedUserPolicies operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListAttachedUserPolicies for more information on using the ListAttachedUserPolicies API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListAttachedUserPoliciesRequest method.
req, resp := client.ListAttachedUserPoliciesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListAttachedUserPoliciesWithContext ¶

func (c *Iam) ListAttachedUserPoliciesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListAttachedUserPoliciesWithContext is the same as ListAttachedUserPolicies with the addition of the ability to pass a context and additional request options.

See ListAttachedUserPolicies for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListEntitiesForPolicy ¶

func (c *Iam) ListEntitiesForPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

ListEntitiesForPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListEntitiesForPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListEntitiesForPolicy

func (*Iam) ListEntitiesForPolicyRequest ¶

func (c *Iam) ListEntitiesForPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListEntitiesForPolicyRequest generates a "ksc/request.Request" representing the client's request for the ListEntitiesForPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListEntitiesForPolicy for more information on using the ListEntitiesForPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListEntitiesForPolicyRequest method.
req, resp := client.ListEntitiesForPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListEntitiesForPolicyWithContext ¶

func (c *Iam) ListEntitiesForPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListEntitiesForPolicyWithContext is the same as ListEntitiesForPolicy with the addition of the ability to pass a context and additional request options.

See ListEntitiesForPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListEntityForPolicy ¶

func (c *Iam) ListEntityForPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

ListEntityForPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListEntityForPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListEntityForPolicy

func (*Iam) ListEntityForPolicyRequest ¶

func (c *Iam) ListEntityForPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListEntityForPolicyRequest generates a "ksc/request.Request" representing the client's request for the ListEntityForPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListEntityForPolicy for more information on using the ListEntityForPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListEntityForPolicyRequest method.
req, resp := client.ListEntityForPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListEntityForPolicyWithContext ¶

func (c *Iam) ListEntityForPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListEntityForPolicyWithContext is the same as ListEntityForPolicy with the addition of the ability to pass a context and additional request options.

See ListEntityForPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListGroupPolicies ¶

func (c *Iam) ListGroupPolicies(input *map[string]interface{}) (*map[string]interface{}, error)

ListGroupPolicies API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListGroupPolicies for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListGroupPolicies

func (*Iam) ListGroupPoliciesRequest ¶

func (c *Iam) ListGroupPoliciesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListGroupPoliciesRequest generates a "ksc/request.Request" representing the client's request for the ListGroupPolicies operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListGroupPolicies for more information on using the ListGroupPolicies API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListGroupPoliciesRequest method.
req, resp := client.ListGroupPoliciesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListGroupPoliciesWithContext ¶

func (c *Iam) ListGroupPoliciesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListGroupPoliciesWithContext is the same as ListGroupPolicies with the addition of the ability to pass a context and additional request options.

See ListGroupPolicies for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListGroups ¶

func (c *Iam) ListGroups(input *map[string]interface{}) (*map[string]interface{}, error)

ListGroups API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListGroups for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListGroups

func (*Iam) ListGroupsForUser ¶

func (c *Iam) ListGroupsForUser(input *map[string]interface{}) (*map[string]interface{}, error)

ListGroupsForUser API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListGroupsForUser for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListGroupsForUser

func (*Iam) ListGroupsForUserRequest ¶

func (c *Iam) ListGroupsForUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListGroupsForUserRequest generates a "ksc/request.Request" representing the client's request for the ListGroupsForUser operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListGroupsForUser for more information on using the ListGroupsForUser API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListGroupsForUserRequest method.
req, resp := client.ListGroupsForUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListGroupsForUserWithContext ¶

func (c *Iam) ListGroupsForUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListGroupsForUserWithContext is the same as ListGroupsForUser with the addition of the ability to pass a context and additional request options.

See ListGroupsForUser for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListGroupsRequest ¶

func (c *Iam) ListGroupsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListGroupsRequest generates a "ksc/request.Request" representing the client's request for the ListGroups operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListGroups for more information on using the ListGroups API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListGroupsRequest method.
req, resp := client.ListGroupsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListGroupsWithContext ¶

func (c *Iam) ListGroupsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListGroupsWithContext is the same as ListGroups with the addition of the ability to pass a context and additional request options.

See ListGroups for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListMiniProgramVirtualMFADevice ¶

func (c *Iam) ListMiniProgramVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

ListMiniProgramVirtualMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListMiniProgramVirtualMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListMiniProgramVirtualMFADevice

func (*Iam) ListMiniProgramVirtualMFADeviceRequest ¶

func (c *Iam) ListMiniProgramVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListMiniProgramVirtualMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the ListMiniProgramVirtualMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListMiniProgramVirtualMFADevice for more information on using the ListMiniProgramVirtualMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListMiniProgramVirtualMFADeviceRequest method.
req, resp := client.ListMiniProgramVirtualMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListMiniProgramVirtualMFADeviceWithContext ¶

func (c *Iam) ListMiniProgramVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListMiniProgramVirtualMFADeviceWithContext is the same as ListMiniProgramVirtualMFADevice with the addition of the ability to pass a context and additional request options.

See ListMiniProgramVirtualMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListPolicies ¶

func (c *Iam) ListPolicies(input *map[string]interface{}) (*map[string]interface{}, error)

ListPolicies API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListPolicies for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListPolicies

func (*Iam) ListPoliciesRequest ¶

func (c *Iam) ListPoliciesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListPoliciesRequest generates a "ksc/request.Request" representing the client's request for the ListPolicies operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListPolicies for more information on using the ListPolicies API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListPoliciesRequest method.
req, resp := client.ListPoliciesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListPoliciesWithContext ¶

func (c *Iam) ListPoliciesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListPoliciesWithContext is the same as ListPolicies with the addition of the ability to pass a context and additional request options.

See ListPolicies for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListPolicyVersions ¶

func (c *Iam) ListPolicyVersions(input *map[string]interface{}) (*map[string]interface{}, error)

ListPolicyVersions API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListPolicyVersions for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListPolicyVersions

func (*Iam) ListPolicyVersionsRequest ¶

func (c *Iam) ListPolicyVersionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListPolicyVersionsRequest generates a "ksc/request.Request" representing the client's request for the ListPolicyVersions operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListPolicyVersions for more information on using the ListPolicyVersions API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListPolicyVersionsRequest method.
req, resp := client.ListPolicyVersionsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListPolicyVersionsWithContext ¶

func (c *Iam) ListPolicyVersionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListPolicyVersionsWithContext is the same as ListPolicyVersions with the addition of the ability to pass a context and additional request options.

See ListPolicyVersions for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListProjectMember ¶

func (c *Iam) ListProjectMember(input *map[string]interface{}) (*map[string]interface{}, error)

ListProjectMember API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListProjectMember for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListProjectMember

func (*Iam) ListProjectMemberRequest ¶

func (c *Iam) ListProjectMemberRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListProjectMemberRequest generates a "ksc/request.Request" representing the client's request for the ListProjectMember operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListProjectMember for more information on using the ListProjectMember API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListProjectMemberRequest method.
req, resp := client.ListProjectMemberRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListProjectMemberWithContext ¶

func (c *Iam) ListProjectMemberWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListProjectMemberWithContext is the same as ListProjectMember with the addition of the ability to pass a context and additional request options.

See ListProjectMember for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListResourceKrn ¶

func (c *Iam) ListResourceKrn(input *map[string]interface{}) (*map[string]interface{}, error)

ListResourceKrn API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListResourceKrn for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListResourceKrn

func (*Iam) ListResourceKrnRequest ¶

func (c *Iam) ListResourceKrnRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListResourceKrnRequest generates a "ksc/request.Request" representing the client's request for the ListResourceKrn operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListResourceKrn for more information on using the ListResourceKrn API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListResourceKrnRequest method.
req, resp := client.ListResourceKrnRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListResourceKrnWithContext ¶

func (c *Iam) ListResourceKrnWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListResourceKrnWithContext is the same as ListResourceKrn with the addition of the ability to pass a context and additional request options.

See ListResourceKrn for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListRoles ¶

func (c *Iam) ListRoles(input *map[string]interface{}) (*map[string]interface{}, error)

ListRoles API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListRoles for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListRoles

func (*Iam) ListRolesRequest ¶

func (c *Iam) ListRolesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListRolesRequest generates a "ksc/request.Request" representing the client's request for the ListRoles operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListRoles for more information on using the ListRoles API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListRolesRequest method.
req, resp := client.ListRolesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListRolesWithContext ¶

func (c *Iam) ListRolesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListRolesWithContext is the same as ListRoles with the addition of the ability to pass a context and additional request options.

See ListRoles for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListServicePerm ¶

func (c *Iam) ListServicePerm(input *map[string]interface{}) (*map[string]interface{}, error)

ListServicePerm API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListServicePerm for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListServicePerm

func (*Iam) ListServicePermRequest ¶

func (c *Iam) ListServicePermRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListServicePermRequest generates a "ksc/request.Request" representing the client's request for the ListServicePerm operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListServicePerm for more information on using the ListServicePerm API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListServicePermRequest method.
req, resp := client.ListServicePermRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListServicePermWithContext ¶

func (c *Iam) ListServicePermWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListServicePermWithContext is the same as ListServicePerm with the addition of the ability to pass a context and additional request options.

See ListServicePerm for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListServiceRolesTpl ¶

func (c *Iam) ListServiceRolesTpl(input *map[string]interface{}) (*map[string]interface{}, error)

ListServiceRolesTpl API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListServiceRolesTpl for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListServiceRolesTpl

func (*Iam) ListServiceRolesTplRequest ¶

func (c *Iam) ListServiceRolesTplRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListServiceRolesTplRequest generates a "ksc/request.Request" representing the client's request for the ListServiceRolesTpl operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListServiceRolesTpl for more information on using the ListServiceRolesTpl API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListServiceRolesTplRequest method.
req, resp := client.ListServiceRolesTplRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListServiceRolesTplWithContext ¶

func (c *Iam) ListServiceRolesTplWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListServiceRolesTplWithContext is the same as ListServiceRolesTpl with the addition of the ability to pass a context and additional request options.

See ListServiceRolesTpl for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListServicesAndActions ¶

func (c *Iam) ListServicesAndActions(input *map[string]interface{}) (*map[string]interface{}, error)

ListServicesAndActions API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListServicesAndActions for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListServicesAndActions

func (*Iam) ListServicesAndActionsRequest ¶

func (c *Iam) ListServicesAndActionsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListServicesAndActionsRequest generates a "ksc/request.Request" representing the client's request for the ListServicesAndActions operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListServicesAndActions for more information on using the ListServicesAndActions API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListServicesAndActionsRequest method.
req, resp := client.ListServicesAndActionsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListServicesAndActionsWithContext ¶

func (c *Iam) ListServicesAndActionsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListServicesAndActionsWithContext is the same as ListServicesAndActions with the addition of the ability to pass a context and additional request options.

See ListServicesAndActions for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListUsers ¶

func (c *Iam) ListUsers(input *map[string]interface{}) (*map[string]interface{}, error)

ListUsers API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListUsers for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListUsers

func (*Iam) ListUsersByIds ¶

func (c *Iam) ListUsersByIds(input *map[string]interface{}) (*map[string]interface{}, error)

ListUsersByIds API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListUsersByIds for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListUsersByIds

func (*Iam) ListUsersByIdsRequest ¶

func (c *Iam) ListUsersByIdsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListUsersByIdsRequest generates a "ksc/request.Request" representing the client's request for the ListUsersByIds operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListUsersByIds for more information on using the ListUsersByIds API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListUsersByIdsRequest method.
req, resp := client.ListUsersByIdsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListUsersByIdsWithContext ¶

func (c *Iam) ListUsersByIdsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListUsersByIdsWithContext is the same as ListUsersByIds with the addition of the ability to pass a context and additional request options.

See ListUsersByIds for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListUsersRequest ¶

func (c *Iam) ListUsersRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListUsersRequest generates a "ksc/request.Request" representing the client's request for the ListUsers operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListUsers for more information on using the ListUsers API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListUsersRequest method.
req, resp := client.ListUsersRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListUsersWithContext ¶

func (c *Iam) ListUsersWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListUsersWithContext is the same as ListUsers with the addition of the ability to pass a context and additional request options.

See ListUsers for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ListVirtualMFADevices ¶

func (c *Iam) ListVirtualMFADevices(input *map[string]interface{}) (*map[string]interface{}, error)

ListVirtualMFADevices API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ListVirtualMFADevices for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ListVirtualMFADevices

func (*Iam) ListVirtualMFADevicesRequest ¶

func (c *Iam) ListVirtualMFADevicesRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ListVirtualMFADevicesRequest generates a "ksc/request.Request" representing the client's request for the ListVirtualMFADevices operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ListVirtualMFADevices for more information on using the ListVirtualMFADevices API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ListVirtualMFADevicesRequest method.
req, resp := client.ListVirtualMFADevicesRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ListVirtualMFADevicesWithContext ¶

func (c *Iam) ListVirtualMFADevicesWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ListVirtualMFADevicesWithContext is the same as ListVirtualMFADevices with the addition of the ability to pass a context and additional request options.

See ListVirtualMFADevices for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) RemoveUserFromGroup ¶

func (c *Iam) RemoveUserFromGroup(input *map[string]interface{}) (*map[string]interface{}, error)

RemoveUserFromGroup API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation RemoveUserFromGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/RemoveUserFromGroup

func (*Iam) RemoveUserFromGroupRequest ¶

func (c *Iam) RemoveUserFromGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

RemoveUserFromGroupRequest generates a "ksc/request.Request" representing the client's request for the RemoveUserFromGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See RemoveUserFromGroup for more information on using the RemoveUserFromGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the RemoveUserFromGroupRequest method.
req, resp := client.RemoveUserFromGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) RemoveUserFromGroupWithContext ¶

func (c *Iam) RemoveUserFromGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

RemoveUserFromGroupWithContext is the same as RemoveUserFromGroup with the addition of the ability to pass a context and additional request options.

See RemoveUserFromGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) SetDefaultPolicyVersion ¶

func (c *Iam) SetDefaultPolicyVersion(input *map[string]interface{}) (*map[string]interface{}, error)

SetDefaultPolicyVersion API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation SetDefaultPolicyVersion for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/SetDefaultPolicyVersion

func (*Iam) SetDefaultPolicyVersionRequest ¶

func (c *Iam) SetDefaultPolicyVersionRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetDefaultPolicyVersionRequest generates a "ksc/request.Request" representing the client's request for the SetDefaultPolicyVersion operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetDefaultPolicyVersion for more information on using the SetDefaultPolicyVersion API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetDefaultPolicyVersionRequest method.
req, resp := client.SetDefaultPolicyVersionRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) SetDefaultPolicyVersionWithContext ¶

func (c *Iam) SetDefaultPolicyVersionWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetDefaultPolicyVersionWithContext is the same as SetDefaultPolicyVersion with the addition of the ability to pass a context and additional request options.

See SetDefaultPolicyVersion for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) SetMemberViewAllProject ¶

func (c *Iam) SetMemberViewAllProject(input *map[string]interface{}) (*map[string]interface{}, error)

SetMemberViewAllProject API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation SetMemberViewAllProject for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/SetMemberViewAllProject

func (*Iam) SetMemberViewAllProjectRequest ¶

func (c *Iam) SetMemberViewAllProjectRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SetMemberViewAllProjectRequest generates a "ksc/request.Request" representing the client's request for the SetMemberViewAllProject operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SetMemberViewAllProject for more information on using the SetMemberViewAllProject API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SetMemberViewAllProjectRequest method.
req, resp := client.SetMemberViewAllProjectRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) SetMemberViewAllProjectWithContext ¶

func (c *Iam) SetMemberViewAllProjectWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SetMemberViewAllProjectWithContext is the same as SetMemberViewAllProject with the addition of the ability to pass a context and additional request options.

See SetMemberViewAllProject for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) SyncMiniProgramVirtualMFADevice ¶

func (c *Iam) SyncMiniProgramVirtualMFADevice(input *map[string]interface{}) (*map[string]interface{}, error)

SyncMiniProgramVirtualMFADevice API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation SyncMiniProgramVirtualMFADevice for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/SyncMiniProgramVirtualMFADevice

func (*Iam) SyncMiniProgramVirtualMFADeviceRequest ¶

func (c *Iam) SyncMiniProgramVirtualMFADeviceRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

SyncMiniProgramVirtualMFADeviceRequest generates a "ksc/request.Request" representing the client's request for the SyncMiniProgramVirtualMFADevice operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See SyncMiniProgramVirtualMFADevice for more information on using the SyncMiniProgramVirtualMFADevice API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the SyncMiniProgramVirtualMFADeviceRequest method.
req, resp := client.SyncMiniProgramVirtualMFADeviceRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) SyncMiniProgramVirtualMFADeviceWithContext ¶

func (c *Iam) SyncMiniProgramVirtualMFADeviceWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

SyncMiniProgramVirtualMFADeviceWithContext is the same as SyncMiniProgramVirtualMFADevice with the addition of the ability to pass a context and additional request options.

See SyncMiniProgramVirtualMFADevice for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) Test ¶

func (c *Iam) Test(input *map[string]interface{}) (*map[string]interface{}, error)

Test API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation Test for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/Test

func (*Iam) TestRequest ¶

func (c *Iam) TestRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

TestRequest generates a "ksc/request.Request" representing the client's request for the Test operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See Test for more information on using the Test API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the TestRequest method.
req, resp := client.TestRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) TestWithContext ¶

func (c *Iam) TestWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

TestWithContext is the same as Test with the addition of the ability to pass a context and additional request options.

See Test for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateAccessKey ¶

func (c *Iam) UpdateAccessKey(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateAccessKey API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateAccessKey for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateAccessKey

func (*Iam) UpdateAccessKeyRequest ¶

func (c *Iam) UpdateAccessKeyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateAccessKeyRequest generates a "ksc/request.Request" representing the client's request for the UpdateAccessKey operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateAccessKey for more information on using the UpdateAccessKey API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateAccessKeyRequest method.
req, resp := client.UpdateAccessKeyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UpdateAccessKeyWithContext ¶

func (c *Iam) UpdateAccessKeyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateAccessKeyWithContext is the same as UpdateAccessKey with the addition of the ability to pass a context and additional request options.

See UpdateAccessKey for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateGroup ¶

func (c *Iam) UpdateGroup(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateGroup API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateGroup for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateGroup

func (*Iam) UpdateGroupRequest ¶

func (c *Iam) UpdateGroupRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateGroupRequest generates a "ksc/request.Request" representing the client's request for the UpdateGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateGroup for more information on using the UpdateGroup API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateGroupRequest method.
req, resp := client.UpdateGroupRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UpdateGroupWithContext ¶

func (c *Iam) UpdateGroupWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateGroupWithContext is the same as UpdateGroup with the addition of the ability to pass a context and additional request options.

See UpdateGroup for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateInstanceProjectId ¶

func (c *Iam) UpdateInstanceProjectId(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateInstanceProjectId API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateInstanceProjectId for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateInstanceProjectId

func (*Iam) UpdateInstanceProjectIdRequest ¶

func (c *Iam) UpdateInstanceProjectIdRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateInstanceProjectIdRequest generates a "ksc/request.Request" representing the client's request for the UpdateInstanceProjectId operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateInstanceProjectId for more information on using the UpdateInstanceProjectId API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateInstanceProjectIdRequest method.
req, resp := client.UpdateInstanceProjectIdRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UpdateInstanceProjectIdWithContext ¶

func (c *Iam) UpdateInstanceProjectIdWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateInstanceProjectIdWithContext is the same as UpdateInstanceProjectId with the addition of the ability to pass a context and additional request options.

See UpdateInstanceProjectId for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateLoginProfile ¶

func (c *Iam) UpdateLoginProfile(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateLoginProfile API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateLoginProfile for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateLoginProfile

func (*Iam) UpdateLoginProfileRequest ¶

func (c *Iam) UpdateLoginProfileRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateLoginProfileRequest generates a "ksc/request.Request" representing the client's request for the UpdateLoginProfile operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateLoginProfile for more information on using the UpdateLoginProfile API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateLoginProfileRequest method.
req, resp := client.UpdateLoginProfileRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UpdateLoginProfileWithContext ¶

func (c *Iam) UpdateLoginProfileWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateLoginProfileWithContext is the same as UpdateLoginProfile with the addition of the ability to pass a context and additional request options.

See UpdateLoginProfile for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdatePolicy ¶

func (c *Iam) UpdatePolicy(input *map[string]interface{}) (*map[string]interface{}, error)

UpdatePolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdatePolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdatePolicy

func (*Iam) UpdatePolicyRequest ¶

func (c *Iam) UpdatePolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdatePolicyRequest generates a "ksc/request.Request" representing the client's request for the UpdatePolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdatePolicy for more information on using the UpdatePolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdatePolicyRequest method.
req, resp := client.UpdatePolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UpdatePolicyWithContext ¶

func (c *Iam) UpdatePolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdatePolicyWithContext is the same as UpdatePolicy with the addition of the ability to pass a context and additional request options.

See UpdatePolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateProjectInfo ¶

func (c *Iam) UpdateProjectInfo(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateProjectInfo API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateProjectInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateProjectInfo

func (*Iam) UpdateProjectInfoRequest ¶

func (c *Iam) UpdateProjectInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateProjectInfoRequest generates a "ksc/request.Request" representing the client's request for the UpdateProjectInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateProjectInfo for more information on using the UpdateProjectInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateProjectInfoRequest method.
req, resp := client.UpdateProjectInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UpdateProjectInfoWithContext ¶

func (c *Iam) UpdateProjectInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateProjectInfoWithContext is the same as UpdateProjectInfo with the addition of the ability to pass a context and additional request options.

See UpdateProjectInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateProjectStatus ¶

func (c *Iam) UpdateProjectStatus(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateProjectStatus API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateProjectStatus for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateProjectStatus

func (*Iam) UpdateProjectStatusRequest ¶

func (c *Iam) UpdateProjectStatusRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateProjectStatusRequest generates a "ksc/request.Request" representing the client's request for the UpdateProjectStatus operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateProjectStatus for more information on using the UpdateProjectStatus API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateProjectStatusRequest method.
req, resp := client.UpdateProjectStatusRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UpdateProjectStatusWithContext ¶

func (c *Iam) UpdateProjectStatusWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateProjectStatusWithContext is the same as UpdateProjectStatus with the addition of the ability to pass a context and additional request options.

See UpdateProjectStatus for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdatePwdPolicy ¶

func (c *Iam) UpdatePwdPolicy(input *map[string]interface{}) (*map[string]interface{}, error)

UpdatePwdPolicy API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdatePwdPolicy for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdatePwdPolicy

func (*Iam) UpdatePwdPolicyRequest ¶

func (c *Iam) UpdatePwdPolicyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdatePwdPolicyRequest generates a "ksc/request.Request" representing the client's request for the UpdatePwdPolicy operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdatePwdPolicy for more information on using the UpdatePwdPolicy API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdatePwdPolicyRequest method.
req, resp := client.UpdatePwdPolicyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UpdatePwdPolicyWithContext ¶

func (c *Iam) UpdatePwdPolicyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdatePwdPolicyWithContext is the same as UpdatePwdPolicy with the addition of the ability to pass a context and additional request options.

See UpdatePwdPolicy for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateRole ¶

func (c *Iam) UpdateRole(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateRole API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateRole for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateRole

func (*Iam) UpdateRoleRequest ¶

func (c *Iam) UpdateRoleRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateRoleRequest generates a "ksc/request.Request" representing the client's request for the UpdateRole operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateRole for more information on using the UpdateRole API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateRoleRequest method.
req, resp := client.UpdateRoleRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UpdateRoleTrustAccounts ¶

func (c *Iam) UpdateRoleTrustAccounts(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateRoleTrustAccounts API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateRoleTrustAccounts for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateRoleTrustAccounts

func (*Iam) UpdateRoleTrustAccountsRequest ¶

func (c *Iam) UpdateRoleTrustAccountsRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateRoleTrustAccountsRequest generates a "ksc/request.Request" representing the client's request for the UpdateRoleTrustAccounts operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateRoleTrustAccounts for more information on using the UpdateRoleTrustAccounts API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateRoleTrustAccountsRequest method.
req, resp := client.UpdateRoleTrustAccountsRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UpdateRoleTrustAccountsWithContext ¶

func (c *Iam) UpdateRoleTrustAccountsWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateRoleTrustAccountsWithContext is the same as UpdateRoleTrustAccounts with the addition of the ability to pass a context and additional request options.

See UpdateRoleTrustAccounts for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateRoleWithContext ¶

func (c *Iam) UpdateRoleWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateRoleWithContext is the same as UpdateRole with the addition of the ability to pass a context and additional request options.

See UpdateRole for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateUser ¶

func (c *Iam) UpdateUser(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateUser API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateUser for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateUser

func (*Iam) UpdateUserContactInfo ¶

func (c *Iam) UpdateUserContactInfo(input *map[string]interface{}) (*map[string]interface{}, error)

UpdateUserContactInfo API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UpdateUserContactInfo for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UpdateUserContactInfo

func (*Iam) UpdateUserContactInfoRequest ¶

func (c *Iam) UpdateUserContactInfoRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateUserContactInfoRequest generates a "ksc/request.Request" representing the client's request for the UpdateUserContactInfo operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateUserContactInfo for more information on using the UpdateUserContactInfo API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateUserContactInfoRequest method.
req, resp := client.UpdateUserContactInfoRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UpdateUserContactInfoWithContext ¶

func (c *Iam) UpdateUserContactInfoWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateUserContactInfoWithContext is the same as UpdateUserContactInfo with the addition of the ability to pass a context and additional request options.

See UpdateUserContactInfo for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UpdateUserRequest ¶

func (c *Iam) UpdateUserRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UpdateUserRequest generates a "ksc/request.Request" representing the client's request for the UpdateUser operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UpdateUser for more information on using the UpdateUser API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UpdateUserRequest method.
req, resp := client.UpdateUserRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UpdateUserWithContext ¶

func (c *Iam) UpdateUserWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UpdateUserWithContext is the same as UpdateUser with the addition of the ability to pass a context and additional request options.

See UpdateUser for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) UserLogin ¶

func (c *Iam) UserLogin(input *map[string]interface{}) (*map[string]interface{}, error)

UserLogin API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation UserLogin for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/UserLogin

func (*Iam) UserLoginRequest ¶

func (c *Iam) UserLoginRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

UserLoginRequest generates a "ksc/request.Request" representing the client's request for the UserLogin operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See UserLogin for more information on using the UserLogin API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the UserLoginRequest method.
req, resp := client.UserLoginRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) UserLoginWithContext ¶

func (c *Iam) UserLoginWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

UserLoginWithContext is the same as UserLogin with the addition of the ability to pass a context and additional request options.

See UserLogin for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ValidPolicyDocument ¶

func (c *Iam) ValidPolicyDocument(input *map[string]interface{}) (*map[string]interface{}, error)

ValidPolicyDocument API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ValidPolicyDocument for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ValidPolicyDocument

func (*Iam) ValidPolicyDocumentRequest ¶

func (c *Iam) ValidPolicyDocumentRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ValidPolicyDocumentRequest generates a "ksc/request.Request" representing the client's request for the ValidPolicyDocument operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ValidPolicyDocument for more information on using the ValidPolicyDocument API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ValidPolicyDocumentRequest method.
req, resp := client.ValidPolicyDocumentRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ValidPolicyDocumentWithContext ¶

func (c *Iam) ValidPolicyDocumentWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ValidPolicyDocumentWithContext is the same as ValidPolicyDocument with the addition of the ability to pass a context and additional request options.

See ValidPolicyDocument for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) ValidProjectId ¶

func (c *Iam) ValidProjectId(input *map[string]interface{}) (*map[string]interface{}, error)

ValidProjectId API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation ValidProjectId for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/ValidProjectId

func (*Iam) ValidProjectIdRequest ¶

func (c *Iam) ValidProjectIdRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

ValidProjectIdRequest generates a "ksc/request.Request" representing the client's request for the ValidProjectId operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See ValidProjectId for more information on using the ValidProjectId API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the ValidProjectIdRequest method.
req, resp := client.ValidProjectIdRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) ValidProjectIdWithContext ¶

func (c *Iam) ValidProjectIdWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

ValidProjectIdWithContext is the same as ValidProjectId with the addition of the ability to pass a context and additional request options.

See ValidProjectId for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) VerificateCompany ¶

func (c *Iam) VerificateCompany(input *map[string]interface{}) (*map[string]interface{}, error)

VerificateCompany API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation VerificateCompany for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/VerificateCompany

func (*Iam) VerificateCompanyRequest ¶

func (c *Iam) VerificateCompanyRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

VerificateCompanyRequest generates a "ksc/request.Request" representing the client's request for the VerificateCompany operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See VerificateCompany for more information on using the VerificateCompany API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the VerificateCompanyRequest method.
req, resp := client.VerificateCompanyRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) VerificateCompanyWithContext ¶

func (c *Iam) VerificateCompanyWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

VerificateCompanyWithContext is the same as VerificateCompany with the addition of the ability to pass a context and additional request options.

See VerificateCompany for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) VerificatePerson ¶

func (c *Iam) VerificatePerson(input *map[string]interface{}) (*map[string]interface{}, error)

VerificatePerson API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation VerificatePerson for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/VerificatePerson

func (*Iam) VerificatePersonRequest ¶

func (c *Iam) VerificatePersonRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

VerificatePersonRequest generates a "ksc/request.Request" representing the client's request for the VerificatePerson operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See VerificatePerson for more information on using the VerificatePerson API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the VerificatePersonRequest method.
req, resp := client.VerificatePersonRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) VerificatePersonWithContext ¶

func (c *Iam) VerificatePersonWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

VerificatePersonWithContext is the same as VerificatePerson with the addition of the ability to pass a context and additional request options.

See VerificatePerson for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

func (*Iam) VerifyMFACode ¶

func (c *Iam) VerifyMFACode(input *map[string]interface{}) (*map[string]interface{}, error)

VerifyMFACode API operation for iam.

Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

See the KSC API reference guide for iam's API operation VerifyMFACode for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/iam-2015-11-01/VerifyMFACode

func (*Iam) VerifyMFACodeRequest ¶

func (c *Iam) VerifyMFACodeRequest(input *map[string]interface{}) (req *request.Request, output *map[string]interface{})

VerifyMFACodeRequest generates a "ksc/request.Request" representing the client's request for the VerifyMFACode operation. The "output" return value will be populated with the request's response once the request completes successfully.

Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

See VerifyMFACode for more information on using the VerifyMFACode API call, and error handling.

This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

// Example sending a request using the VerifyMFACodeRequest method.
req, resp := client.VerifyMFACodeRequest(params)

err := req.Send()
if err == nil { // resp is now filled
    fmt.Println(resp)
}

func (*Iam) VerifyMFACodeWithContext ¶

func (c *Iam) VerifyMFACodeWithContext(ctx aws.Context, input *map[string]interface{}, opts ...request.Option) (*map[string]interface{}, error)

VerifyMFACodeWithContext is the same as VerifyMFACode with the addition of the ability to pass a context and additional request options.

See VerifyMFACode for details on how to use this API operation.

The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
iamiface Package iamiface provides an interface to enable mocking the iam service client for testing your code.	Package iamiface provides an interface to enable mocking the iam service client for testing your code.

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL