Documentation

Overview

    Package mq provides the API client, operations, and parameter types for AmazonMQ.

    Amazon MQ is a managed message broker service for Apache ActiveMQ and RabbitMQ that makes it easy to set up and operate message brokers in the cloud. A message broker allows software applications and components to communicate using various programming languages, operating systems, and formal messaging protocols.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2017-11-27"
    View Source
    const ServiceID = "mq"

    Variables

    This section is empty.

    Functions

    func NewDefaultEndpointResolver

    func NewDefaultEndpointResolver() *internalendpoints.Resolver

      NewDefaultEndpointResolver constructs a new service endpoint resolver

      func WithAPIOptions

      func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options)

        WithAPIOptions returns a functional option for setting the Client's APIOptions option.

        func WithEndpointResolver

        func WithEndpointResolver(v EndpointResolver) func(*Options)

          WithEndpointResolver returns a functional option for setting the Client's EndpointResolver option.

          Types

          type Client

          type Client struct {
          	// contains filtered or unexported fields
          }

            Client provides the API client to make operations call for AmazonMQ.

            func New

            func New(options Options, optFns ...func(*Options)) *Client

              New returns an initialized Client based on the functional options. Provide additional functional options to further configure the behavior of the client, such as changing the client's endpoint or adding custom middleware behavior.

              func NewFromConfig

              func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client

                NewFromConfig returns a new client from the provided config.

                func (*Client) CreateBroker

                func (c *Client) CreateBroker(ctx context.Context, params *CreateBrokerInput, optFns ...func(*Options)) (*CreateBrokerOutput, error)

                  Creates a broker. Note: This API is asynchronous.

                  func (*Client) CreateConfiguration

                  func (c *Client) CreateConfiguration(ctx context.Context, params *CreateConfigurationInput, optFns ...func(*Options)) (*CreateConfigurationOutput, error)

                    Creates a new configuration for the specified configuration name. Amazon MQ uses the default configuration (the engine type and version).

                    func (*Client) CreateTags

                    func (c *Client) CreateTags(ctx context.Context, params *CreateTagsInput, optFns ...func(*Options)) (*CreateTagsOutput, error)

                      Add a tag to a resource.

                      func (*Client) CreateUser

                      func (c *Client) CreateUser(ctx context.Context, params *CreateUserInput, optFns ...func(*Options)) (*CreateUserOutput, error)

                        Creates an ActiveMQ user.

                        func (*Client) DeleteBroker

                        func (c *Client) DeleteBroker(ctx context.Context, params *DeleteBrokerInput, optFns ...func(*Options)) (*DeleteBrokerOutput, error)

                          Deletes a broker. Note: This API is asynchronous.

                          func (*Client) DeleteTags

                          func (c *Client) DeleteTags(ctx context.Context, params *DeleteTagsInput, optFns ...func(*Options)) (*DeleteTagsOutput, error)

                            Removes a tag from a resource.

                            func (*Client) DeleteUser

                            func (c *Client) DeleteUser(ctx context.Context, params *DeleteUserInput, optFns ...func(*Options)) (*DeleteUserOutput, error)

                              Deletes an ActiveMQ user.

                              func (*Client) DescribeBroker

                              func (c *Client) DescribeBroker(ctx context.Context, params *DescribeBrokerInput, optFns ...func(*Options)) (*DescribeBrokerOutput, error)

                                Returns information about the specified broker.

                                func (*Client) DescribeBrokerEngineTypes

                                func (c *Client) DescribeBrokerEngineTypes(ctx context.Context, params *DescribeBrokerEngineTypesInput, optFns ...func(*Options)) (*DescribeBrokerEngineTypesOutput, error)

                                  Describe available engine types and versions.

                                  func (*Client) DescribeBrokerInstanceOptions

                                  func (c *Client) DescribeBrokerInstanceOptions(ctx context.Context, params *DescribeBrokerInstanceOptionsInput, optFns ...func(*Options)) (*DescribeBrokerInstanceOptionsOutput, error)

                                    Describe available broker instance options.

                                    func (*Client) DescribeConfiguration

                                    func (c *Client) DescribeConfiguration(ctx context.Context, params *DescribeConfigurationInput, optFns ...func(*Options)) (*DescribeConfigurationOutput, error)

                                      Returns information about the specified configuration.

                                      func (*Client) DescribeConfigurationRevision

                                      func (c *Client) DescribeConfigurationRevision(ctx context.Context, params *DescribeConfigurationRevisionInput, optFns ...func(*Options)) (*DescribeConfigurationRevisionOutput, error)

                                        Returns the specified configuration revision for the specified configuration.

                                        func (*Client) DescribeUser

                                        func (c *Client) DescribeUser(ctx context.Context, params *DescribeUserInput, optFns ...func(*Options)) (*DescribeUserOutput, error)

                                          Returns information about an ActiveMQ user.

                                          func (*Client) ListBrokers

                                          func (c *Client) ListBrokers(ctx context.Context, params *ListBrokersInput, optFns ...func(*Options)) (*ListBrokersOutput, error)

                                            Returns a list of all brokers.

                                            func (*Client) ListConfigurationRevisions

                                            func (c *Client) ListConfigurationRevisions(ctx context.Context, params *ListConfigurationRevisionsInput, optFns ...func(*Options)) (*ListConfigurationRevisionsOutput, error)

                                              Returns a list of all revisions for the specified configuration.

                                              func (*Client) ListConfigurations

                                              func (c *Client) ListConfigurations(ctx context.Context, params *ListConfigurationsInput, optFns ...func(*Options)) (*ListConfigurationsOutput, error)

                                                Returns a list of all configurations.

                                                func (*Client) ListTags

                                                func (c *Client) ListTags(ctx context.Context, params *ListTagsInput, optFns ...func(*Options)) (*ListTagsOutput, error)

                                                  Lists tags for a resource.

                                                  func (*Client) ListUsers

                                                  func (c *Client) ListUsers(ctx context.Context, params *ListUsersInput, optFns ...func(*Options)) (*ListUsersOutput, error)

                                                    Returns a list of all ActiveMQ users.

                                                    func (*Client) RebootBroker

                                                    func (c *Client) RebootBroker(ctx context.Context, params *RebootBrokerInput, optFns ...func(*Options)) (*RebootBrokerOutput, error)

                                                      Reboots a broker. Note: This API is asynchronous.

                                                      func (*Client) UpdateBroker

                                                      func (c *Client) UpdateBroker(ctx context.Context, params *UpdateBrokerInput, optFns ...func(*Options)) (*UpdateBrokerOutput, error)

                                                        Adds a pending configuration change to a broker.

                                                        func (*Client) UpdateConfiguration

                                                        func (c *Client) UpdateConfiguration(ctx context.Context, params *UpdateConfigurationInput, optFns ...func(*Options)) (*UpdateConfigurationOutput, error)

                                                          Updates the specified configuration.

                                                          func (*Client) UpdateUser

                                                          func (c *Client) UpdateUser(ctx context.Context, params *UpdateUserInput, optFns ...func(*Options)) (*UpdateUserOutput, error)

                                                            Updates the information for an ActiveMQ user.

                                                            type CreateBrokerInput

                                                            type CreateBrokerInput struct {
                                                            
                                                            	// The authentication strategy used to secure the broker.
                                                            	AuthenticationStrategy types.AuthenticationStrategy
                                                            
                                                            	// Required. Enables automatic upgrades to new minor versions for brokers, as
                                                            	// Apache releases the versions. The automatic upgrades occur during the
                                                            	// maintenance window of the broker or after a manual broker reboot.
                                                            	AutoMinorVersionUpgrade bool
                                                            
                                                            	// Required. The name of the broker. This value must be unique in your AWS account,
                                                            	// 1-50 characters long, must contain only letters, numbers, dashes, and
                                                            	// underscores, and must not contain whitespaces, brackets, wildcard characters, or
                                                            	// special characters.
                                                            	BrokerName *string
                                                            
                                                            	// A list of information about the configuration.
                                                            	Configuration *types.ConfigurationId
                                                            
                                                            	// The unique ID that the requester receives for the created broker. Amazon MQ
                                                            	// passes your ID with the API action. Note: We recommend using a Universally
                                                            	// Unique Identifier (UUID) for the creatorRequestId. You may omit the
                                                            	// creatorRequestId if your application doesn't require idempotency.
                                                            	CreatorRequestId *string
                                                            
                                                            	// Required. The deployment mode of the broker.
                                                            	DeploymentMode types.DeploymentMode
                                                            
                                                            	// Encryption options for the broker.
                                                            	EncryptionOptions *types.EncryptionOptions
                                                            
                                                            	// Required. The type of broker engine. Note: Currently, Amazon MQ supports
                                                            	// ACTIVEMQ and RABBITMQ.
                                                            	EngineType types.EngineType
                                                            
                                                            	// Required. The version of the broker engine. For a list of supported engine
                                                            	// versions, see
                                                            	// https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/broker-engine.html
                                                            	EngineVersion *string
                                                            
                                                            	// Required. The broker's instance type.
                                                            	HostInstanceType *string
                                                            
                                                            	// The metadata of the LDAP server used to authenticate and authorize connections
                                                            	// to the broker.
                                                            	LdapServerMetadata *types.LdapServerMetadataInput
                                                            
                                                            	// Enables Amazon CloudWatch logging for brokers.
                                                            	Logs *types.Logs
                                                            
                                                            	// The parameters that determine the WeeklyStartTime.
                                                            	MaintenanceWindowStartTime *types.WeeklyStartTime
                                                            
                                                            	// Required. Enables connections from applications outside of the VPC that hosts
                                                            	// the broker's subnets.
                                                            	PubliclyAccessible bool
                                                            
                                                            	// The list of security groups (1 minimum, 5 maximum) that authorizes connections
                                                            	// to brokers.
                                                            	SecurityGroups []string
                                                            
                                                            	// The broker's storage type.
                                                            	StorageType types.BrokerStorageType
                                                            
                                                            	// The list of groups that define which subnets and IP ranges the broker can use
                                                            	// from different Availability Zones. A SINGLE_INSTANCE deployment requires one
                                                            	// subnet (for example, the default subnet). An ACTIVE_STANDBY_MULTI_AZ deployment
                                                            	// (ACTIVEMQ) requires two subnets. A CLUSTER_MULTI_AZ deployment (RABBITMQ) has no
                                                            	// subnet requirements when deployed with public accessibility, deployment without
                                                            	// public accessibility requires at least one subnet.
                                                            	SubnetIds []string
                                                            
                                                            	// Create tags when creating the broker.
                                                            	Tags map[string]string
                                                            
                                                            	// Required. The list of broker users (persons or applications) who can access
                                                            	// queues and topics. For RabbitMQ brokers, one and only one administrative user is
                                                            	// accepted and created when a broker is first provisioned. All subsequent broker
                                                            	// users are created by making RabbitMQ API calls directly to brokers or via the
                                                            	// RabbitMQ Web Console. This value can contain only alphanumeric characters,
                                                            	// dashes, periods, underscores, and tildes (- . _ ~). This value must be 2-100
                                                            	// characters long.
                                                            	Users []types.User
                                                            }

                                                              Creates a broker using the specified properties.

                                                              type CreateBrokerOutput

                                                              type CreateBrokerOutput struct {
                                                              
                                                              	// The Amazon Resource Name (ARN) of the broker.
                                                              	BrokerArn *string
                                                              
                                                              	// The unique ID that Amazon MQ generates for the broker.
                                                              	BrokerId *string
                                                              
                                                              	// Metadata pertaining to the operation's result.
                                                              	ResultMetadata middleware.Metadata
                                                              }

                                                              type CreateConfigurationInput

                                                              type CreateConfigurationInput struct {
                                                              
                                                              	// The authentication strategy associated with the configuration.
                                                              	AuthenticationStrategy types.AuthenticationStrategy
                                                              
                                                              	// Required. The type of broker engine. Note: Currently, Amazon MQ supports
                                                              	// ACTIVEMQ and RABBITMQ.
                                                              	EngineType types.EngineType
                                                              
                                                              	// Required. The version of the broker engine. For a list of supported engine
                                                              	// versions, see
                                                              	// https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/broker-engine.html
                                                              	EngineVersion *string
                                                              
                                                              	// Required. The name of the configuration. This value can contain only
                                                              	// alphanumeric characters, dashes, periods, underscores, and tildes (- . _ ~).
                                                              	// This value must be 1-150 characters long.
                                                              	Name *string
                                                              
                                                              	// Create tags when creating the configuration.
                                                              	Tags map[string]string
                                                              }

                                                                Creates a new configuration for the specified configuration name. Amazon MQ uses the default configuration (the engine type and version).

                                                                type CreateConfigurationOutput

                                                                type CreateConfigurationOutput struct {
                                                                
                                                                	// Required. The Amazon Resource Name (ARN) of the configuration.
                                                                	Arn *string
                                                                
                                                                	// The authentication strategy associated with the configuration.
                                                                	AuthenticationStrategy types.AuthenticationStrategy
                                                                
                                                                	// Required. The date and time of the configuration.
                                                                	Created *time.Time
                                                                
                                                                	// Required. The unique ID that Amazon MQ generates for the configuration.
                                                                	Id *string
                                                                
                                                                	// The latest revision of the configuration.
                                                                	LatestRevision *types.ConfigurationRevision
                                                                
                                                                	// Required. The name of the configuration. This value can contain only
                                                                	// alphanumeric characters, dashes, periods, underscores, and tildes (- . _ ~).
                                                                	// This value must be 1-150 characters long.
                                                                	Name *string
                                                                
                                                                	// Metadata pertaining to the operation's result.
                                                                	ResultMetadata middleware.Metadata
                                                                }

                                                                type CreateTagsInput

                                                                type CreateTagsInput struct {
                                                                
                                                                	// The Amazon Resource Name (ARN) of the resource tag.
                                                                	//
                                                                	// This member is required.
                                                                	ResourceArn *string
                                                                
                                                                	// The key-value pair for the resource tag.
                                                                	Tags map[string]string
                                                                }

                                                                  A map of the key-value pairs for the resource tag.

                                                                  type CreateTagsOutput

                                                                  type CreateTagsOutput struct {
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type CreateUserInput

                                                                  type CreateUserInput struct {
                                                                  
                                                                  	// The unique ID that Amazon MQ generates for the broker.
                                                                  	//
                                                                  	// This member is required.
                                                                  	BrokerId *string
                                                                  
                                                                  	// The username of the ActiveMQ user. This value can contain only alphanumeric
                                                                  	// characters, dashes, periods, underscores, and tildes (- . _ ~). This value must
                                                                  	// be 2-100 characters long.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Username *string
                                                                  
                                                                  	// Enables access to the the ActiveMQ Web Console for the ActiveMQ user.
                                                                  	ConsoleAccess bool
                                                                  
                                                                  	// The list of groups (20 maximum) to which the ActiveMQ user belongs. This value
                                                                  	// can contain only alphanumeric characters, dashes, periods, underscores, and
                                                                  	// tildes (- . _ ~). This value must be 2-100 characters long.
                                                                  	Groups []string
                                                                  
                                                                  	// Required. The password of the user. This value must be at least 12 characters
                                                                  	// long, must contain at least 4 unique characters, and must not contain commas.
                                                                  	Password *string
                                                                  }

                                                                    Creates a new ActiveMQ user.

                                                                    type CreateUserOutput

                                                                    type CreateUserOutput struct {
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type DeleteBrokerInput

                                                                    type DeleteBrokerInput struct {
                                                                    
                                                                    	// The unique ID that Amazon MQ generates for the broker.
                                                                    	//
                                                                    	// This member is required.
                                                                    	BrokerId *string
                                                                    }

                                                                    type DeleteBrokerOutput

                                                                    type DeleteBrokerOutput struct {
                                                                    
                                                                    	// The unique ID that Amazon MQ generates for the broker.
                                                                    	BrokerId *string
                                                                    
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type DeleteTagsInput

                                                                    type DeleteTagsInput struct {
                                                                    
                                                                    	// The Amazon Resource Name (ARN) of the resource tag.
                                                                    	//
                                                                    	// This member is required.
                                                                    	ResourceArn *string
                                                                    
                                                                    	// An array of tag keys to delete
                                                                    	//
                                                                    	// This member is required.
                                                                    	TagKeys []string
                                                                    }

                                                                    type DeleteTagsOutput

                                                                    type DeleteTagsOutput struct {
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type DeleteUserInput

                                                                    type DeleteUserInput struct {
                                                                    
                                                                    	// The unique ID that Amazon MQ generates for the broker.
                                                                    	//
                                                                    	// This member is required.
                                                                    	BrokerId *string
                                                                    
                                                                    	// The username of the ActiveMQ user. This value can contain only alphanumeric
                                                                    	// characters, dashes, periods, underscores, and tildes (- . _ ~). This value must
                                                                    	// be 2-100 characters long.
                                                                    	//
                                                                    	// This member is required.
                                                                    	Username *string
                                                                    }

                                                                    type DeleteUserOutput

                                                                    type DeleteUserOutput struct {
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type DescribeBrokerEngineTypesInput

                                                                    type DescribeBrokerEngineTypesInput struct {
                                                                    
                                                                    	// Filter response by engine type.
                                                                    	EngineType *string
                                                                    
                                                                    	// The maximum number of engine types that Amazon MQ can return per page (20 by
                                                                    	// default). This value must be an integer from 5 to 100.
                                                                    	MaxResults int32
                                                                    
                                                                    	// The token that specifies the next page of results Amazon MQ should return. To
                                                                    	// request the first page, leave nextToken empty.
                                                                    	NextToken *string
                                                                    }

                                                                    type DescribeBrokerEngineTypesOutput

                                                                    type DescribeBrokerEngineTypesOutput struct {
                                                                    
                                                                    	// List of available engine types and versions.
                                                                    	BrokerEngineTypes []types.BrokerEngineType
                                                                    
                                                                    	// Required. The maximum number of engine types that can be returned per page (20
                                                                    	// by default). This value must be an integer from 5 to 100.
                                                                    	MaxResults int32
                                                                    
                                                                    	// The token that specifies the next page of results Amazon MQ should return. To
                                                                    	// request the first page, leave nextToken empty.
                                                                    	NextToken *string
                                                                    
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type DescribeBrokerInput

                                                                    type DescribeBrokerInput struct {
                                                                    
                                                                    	// The name of the broker. This value must be unique in your AWS account, 1-50
                                                                    	// characters long, must contain only letters, numbers, dashes, and underscores,
                                                                    	// and must not contain whitespaces, brackets, wildcard characters, or special
                                                                    	// characters.
                                                                    	//
                                                                    	// This member is required.
                                                                    	BrokerId *string
                                                                    }

                                                                    type DescribeBrokerInstanceOptionsInput

                                                                    type DescribeBrokerInstanceOptionsInput struct {
                                                                    
                                                                    	// Filter response by engine type.
                                                                    	EngineType *string
                                                                    
                                                                    	// Filter response by host instance type.
                                                                    	HostInstanceType *string
                                                                    
                                                                    	// The maximum number of instance options that Amazon MQ can return per page (20 by
                                                                    	// default). This value must be an integer from 5 to 100.
                                                                    	MaxResults int32
                                                                    
                                                                    	// The token that specifies the next page of results Amazon MQ should return. To
                                                                    	// request the first page, leave nextToken empty.
                                                                    	NextToken *string
                                                                    
                                                                    	// Filter response by storage type.
                                                                    	StorageType *string
                                                                    }

                                                                    type DescribeBrokerInstanceOptionsOutput

                                                                    type DescribeBrokerInstanceOptionsOutput struct {
                                                                    
                                                                    	// List of available broker instance options.
                                                                    	BrokerInstanceOptions []types.BrokerInstanceOption
                                                                    
                                                                    	// Required. The maximum number of instance options that can be returned per page
                                                                    	// (20 by default). This value must be an integer from 5 to 100.
                                                                    	MaxResults int32
                                                                    
                                                                    	// The token that specifies the next page of results Amazon MQ should return. To
                                                                    	// request the first page, leave nextToken empty.
                                                                    	NextToken *string
                                                                    
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type DescribeBrokerOutput

                                                                    type DescribeBrokerOutput struct {
                                                                    
                                                                    	// The authentication strategy used to secure the broker.
                                                                    	AuthenticationStrategy types.AuthenticationStrategy
                                                                    
                                                                    	// Required. Enables automatic upgrades to new minor versions for brokers, as
                                                                    	// Apache releases the versions. The automatic upgrades occur during the
                                                                    	// maintenance window of the broker or after a manual broker reboot.
                                                                    	AutoMinorVersionUpgrade bool
                                                                    
                                                                    	// The Amazon Resource Name (ARN) of the broker.
                                                                    	BrokerArn *string
                                                                    
                                                                    	// The unique ID that Amazon MQ generates for the broker.
                                                                    	BrokerId *string
                                                                    
                                                                    	// A list of information about allocated brokers.
                                                                    	BrokerInstances []types.BrokerInstance
                                                                    
                                                                    	// The name of the broker. This value must be unique in your AWS account, 1-50
                                                                    	// characters long, must contain only letters, numbers, dashes, and underscores,
                                                                    	// and must not contain whitespaces, brackets, wildcard characters, or special
                                                                    	// characters.
                                                                    	BrokerName *string
                                                                    
                                                                    	// The status of the broker.
                                                                    	BrokerState types.BrokerState
                                                                    
                                                                    	// The list of all revisions for the specified configuration.
                                                                    	Configurations *types.Configurations
                                                                    
                                                                    	// The time when the broker was created.
                                                                    	Created *time.Time
                                                                    
                                                                    	// Required. The deployment mode of the broker.
                                                                    	DeploymentMode types.DeploymentMode
                                                                    
                                                                    	// Encryption options for the broker.
                                                                    	EncryptionOptions *types.EncryptionOptions
                                                                    
                                                                    	// Required. The type of broker engine. Note: Currently, Amazon MQ supports
                                                                    	// ACTIVEMQ and RABBITMQ.
                                                                    	EngineType types.EngineType
                                                                    
                                                                    	// The version of the broker engine. For a list of supported engine versions, see
                                                                    	// https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/broker-engine.html
                                                                    	EngineVersion *string
                                                                    
                                                                    	// The broker's instance type.
                                                                    	HostInstanceType *string
                                                                    
                                                                    	// The metadata of the LDAP server used to authenticate and authorize connections
                                                                    	// to the broker.
                                                                    	LdapServerMetadata *types.LdapServerMetadataOutput
                                                                    
                                                                    	// The list of information about logs currently enabled and pending to be deployed
                                                                    	// for the specified broker.
                                                                    	Logs *types.LogsSummary
                                                                    
                                                                    	// The parameters that determine the WeeklyStartTime.
                                                                    	MaintenanceWindowStartTime *types.WeeklyStartTime
                                                                    
                                                                    	// The authentication strategy that will be applied when the broker is rebooted.
                                                                    	PendingAuthenticationStrategy types.AuthenticationStrategy
                                                                    
                                                                    	// The version of the broker engine to upgrade to. For a list of supported engine
                                                                    	// versions, see
                                                                    	// https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/broker-engine.html
                                                                    	PendingEngineVersion *string
                                                                    
                                                                    	// The host instance type of the broker to upgrade to. For a list of supported
                                                                    	// instance types, see
                                                                    	// https://docs.aws.amazon.com/amazon-mq/latest/developer-guide//broker.html#broker-instance-types
                                                                    	PendingHostInstanceType *string
                                                                    
                                                                    	// The metadata of the LDAP server that will be used to authenticate and authorize
                                                                    	// connections to the broker once it is rebooted.
                                                                    	PendingLdapServerMetadata *types.LdapServerMetadataOutput
                                                                    
                                                                    	// The list of pending security groups to authorize connections to brokers.
                                                                    	PendingSecurityGroups []string
                                                                    
                                                                    	// Required. Enables connections from applications outside of the VPC that hosts
                                                                    	// the broker's subnets.
                                                                    	PubliclyAccessible bool
                                                                    
                                                                    	// The list of security groups (1 minimum, 5 maximum) that authorizes connections
                                                                    	// to brokers.
                                                                    	SecurityGroups []string
                                                                    
                                                                    	// The broker's storage type.
                                                                    	StorageType types.BrokerStorageType
                                                                    
                                                                    	// The list of groups that define which subnets and IP ranges the broker can use
                                                                    	// from different Availability Zones. A SINGLE_INSTANCE deployment requires one
                                                                    	// subnet (for example, the default subnet). An ACTIVE_STANDBY_MULTI_AZ deployment
                                                                    	// (ACTIVEMQ) requires two subnets. A CLUSTER_MULTI_AZ deployment (RABBITMQ) has no
                                                                    	// subnet requirements when deployed with public accessibility, deployment without
                                                                    	// public accessibility requires at least one subnet.
                                                                    	SubnetIds []string
                                                                    
                                                                    	// The list of all tags associated with this broker.
                                                                    	Tags map[string]string
                                                                    
                                                                    	// The list of all broker usernames for the specified broker.
                                                                    	Users []types.UserSummary
                                                                    
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type DescribeConfigurationInput

                                                                    type DescribeConfigurationInput struct {
                                                                    
                                                                    	// The unique ID that Amazon MQ generates for the configuration.
                                                                    	//
                                                                    	// This member is required.
                                                                    	ConfigurationId *string
                                                                    }

                                                                    type DescribeConfigurationOutput

                                                                    type DescribeConfigurationOutput struct {
                                                                    
                                                                    	// Required. The ARN of the configuration.
                                                                    	Arn *string
                                                                    
                                                                    	// The authentication strategy associated with the configuration.
                                                                    	AuthenticationStrategy types.AuthenticationStrategy
                                                                    
                                                                    	// Required. The date and time of the configuration revision.
                                                                    	Created *time.Time
                                                                    
                                                                    	// Required. The description of the configuration.
                                                                    	Description *string
                                                                    
                                                                    	// Required. The type of broker engine. Note: Currently, Amazon MQ supports
                                                                    	// ACTIVEMQ and RABBITMQ.
                                                                    	EngineType types.EngineType
                                                                    
                                                                    	// Required. The version of the broker engine. For a list of supported engine
                                                                    	// versions, see
                                                                    	// https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/broker-engine.html
                                                                    	EngineVersion *string
                                                                    
                                                                    	// Required. The unique ID that Amazon MQ generates for the configuration.
                                                                    	Id *string
                                                                    
                                                                    	// Required. The latest revision of the configuration.
                                                                    	LatestRevision *types.ConfigurationRevision
                                                                    
                                                                    	// Required. The name of the configuration. This value can contain only
                                                                    	// alphanumeric characters, dashes, periods, underscores, and tildes (- . _ ~).
                                                                    	// This value must be 1-150 characters long.
                                                                    	Name *string
                                                                    
                                                                    	// The list of all tags associated with this configuration.
                                                                    	Tags map[string]string
                                                                    
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type DescribeConfigurationRevisionInput

                                                                    type DescribeConfigurationRevisionInput struct {
                                                                    
                                                                    	// The unique ID that Amazon MQ generates for the configuration.
                                                                    	//
                                                                    	// This member is required.
                                                                    	ConfigurationId *string
                                                                    
                                                                    	// The revision of the configuration.
                                                                    	//
                                                                    	// This member is required.
                                                                    	ConfigurationRevision *string
                                                                    }

                                                                    type DescribeConfigurationRevisionOutput

                                                                    type DescribeConfigurationRevisionOutput struct {
                                                                    
                                                                    	// Required. The unique ID that Amazon MQ generates for the configuration.
                                                                    	ConfigurationId *string
                                                                    
                                                                    	// Required. The date and time of the configuration.
                                                                    	Created *time.Time
                                                                    
                                                                    	// Required. The base64-encoded XML configuration.
                                                                    	Data *string
                                                                    
                                                                    	// The description of the configuration.
                                                                    	Description *string
                                                                    
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type DescribeUserInput

                                                                    type DescribeUserInput struct {
                                                                    
                                                                    	// The unique ID that Amazon MQ generates for the broker.
                                                                    	//
                                                                    	// This member is required.
                                                                    	BrokerId *string
                                                                    
                                                                    	// The username of the ActiveMQ user. This value can contain only alphanumeric
                                                                    	// characters, dashes, periods, underscores, and tildes (- . _ ~). This value must
                                                                    	// be 2-100 characters long.
                                                                    	//
                                                                    	// This member is required.
                                                                    	Username *string
                                                                    }

                                                                    type DescribeUserOutput

                                                                    type DescribeUserOutput struct {
                                                                    
                                                                    	// Required. The unique ID that Amazon MQ generates for the broker.
                                                                    	BrokerId *string
                                                                    
                                                                    	// Enables access to the the ActiveMQ Web Console for the ActiveMQ user.
                                                                    	ConsoleAccess bool
                                                                    
                                                                    	// The list of groups (20 maximum) to which the ActiveMQ user belongs. This value
                                                                    	// can contain only alphanumeric characters, dashes, periods, underscores, and
                                                                    	// tildes (- . _ ~). This value must be 2-100 characters long.
                                                                    	Groups []string
                                                                    
                                                                    	// The status of the changes pending for the ActiveMQ user.
                                                                    	Pending *types.UserPendingChanges
                                                                    
                                                                    	// Required. The username of the ActiveMQ user. This value can contain only
                                                                    	// alphanumeric characters, dashes, periods, underscores, and tildes (- . _ ~).
                                                                    	// This value must be 2-100 characters long.
                                                                    	Username *string
                                                                    
                                                                    	// Metadata pertaining to the operation's result.
                                                                    	ResultMetadata middleware.Metadata
                                                                    }

                                                                    type EndpointResolver

                                                                    type EndpointResolver interface {
                                                                    	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
                                                                    }

                                                                      EndpointResolver interface for resolving service endpoints.

                                                                      func EndpointResolverFromURL

                                                                      func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver

                                                                        EndpointResolverFromURL returns an EndpointResolver configured using the provided endpoint url. By default, the resolved endpoint resolver uses the client region as signing region, and the endpoint source is set to EndpointSourceCustom.You can provide functional options to configure endpoint values for the resolved endpoint.

                                                                        type EndpointResolverFunc

                                                                        type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

                                                                          EndpointResolverFunc is a helper utility that wraps a function so it satisfies the EndpointResolver interface. This is useful when you want to add additional endpoint resolving logic, or stub out specific endpoints with custom values.

                                                                          func (EndpointResolverFunc) ResolveEndpoint

                                                                          func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error)

                                                                          type EndpointResolverOptions

                                                                          type EndpointResolverOptions = internalendpoints.Options

                                                                            EndpointResolverOptions is the service endpoint resolver options

                                                                            type HTTPClient

                                                                            type HTTPClient interface {
                                                                            	Do(*http.Request) (*http.Response, error)
                                                                            }

                                                                            type HTTPSignerV4

                                                                            type HTTPSignerV4 interface {
                                                                            	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
                                                                            }

                                                                            type IdempotencyTokenProvider

                                                                            type IdempotencyTokenProvider interface {
                                                                            	GetIdempotencyToken() (string, error)
                                                                            }

                                                                              IdempotencyTokenProvider interface for providing idempotency token

                                                                              type ListBrokersAPIClient

                                                                              type ListBrokersAPIClient interface {
                                                                              	ListBrokers(context.Context, *ListBrokersInput, ...func(*Options)) (*ListBrokersOutput, error)
                                                                              }

                                                                                ListBrokersAPIClient is a client that implements the ListBrokers operation.

                                                                                type ListBrokersInput

                                                                                type ListBrokersInput struct {
                                                                                
                                                                                	// The maximum number of brokers that Amazon MQ can return per page (20 by
                                                                                	// default). This value must be an integer from 5 to 100.
                                                                                	MaxResults int32
                                                                                
                                                                                	// The token that specifies the next page of results Amazon MQ should return. To
                                                                                	// request the first page, leave nextToken empty.
                                                                                	NextToken *string
                                                                                }

                                                                                type ListBrokersOutput

                                                                                type ListBrokersOutput struct {
                                                                                
                                                                                	// A list of information about all brokers.
                                                                                	BrokerSummaries []types.BrokerSummary
                                                                                
                                                                                	// The token that specifies the next page of results Amazon MQ should return. To
                                                                                	// request the first page, leave nextToken empty.
                                                                                	NextToken *string
                                                                                
                                                                                	// Metadata pertaining to the operation's result.
                                                                                	ResultMetadata middleware.Metadata
                                                                                }

                                                                                type ListBrokersPaginator

                                                                                type ListBrokersPaginator struct {
                                                                                	// contains filtered or unexported fields
                                                                                }

                                                                                  ListBrokersPaginator is a paginator for ListBrokers

                                                                                  func NewListBrokersPaginator

                                                                                  func NewListBrokersPaginator(client ListBrokersAPIClient, params *ListBrokersInput, optFns ...func(*ListBrokersPaginatorOptions)) *ListBrokersPaginator

                                                                                    NewListBrokersPaginator returns a new ListBrokersPaginator

                                                                                    func (*ListBrokersPaginator) HasMorePages

                                                                                    func (p *ListBrokersPaginator) HasMorePages() bool

                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                      func (*ListBrokersPaginator) NextPage

                                                                                      func (p *ListBrokersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListBrokersOutput, error)

                                                                                        NextPage retrieves the next ListBrokers page.

                                                                                        type ListBrokersPaginatorOptions

                                                                                        type ListBrokersPaginatorOptions struct {
                                                                                        	// The maximum number of brokers that Amazon MQ can return per page (20 by
                                                                                        	// default). This value must be an integer from 5 to 100.
                                                                                        	Limit int32
                                                                                        
                                                                                        	// Set to true if pagination should stop if the service returns a pagination token
                                                                                        	// that matches the most recent token provided to the service.
                                                                                        	StopOnDuplicateToken bool
                                                                                        }

                                                                                          ListBrokersPaginatorOptions is the paginator options for ListBrokers

                                                                                          type ListConfigurationRevisionsInput

                                                                                          type ListConfigurationRevisionsInput struct {
                                                                                          
                                                                                          	// The unique ID that Amazon MQ generates for the configuration.
                                                                                          	//
                                                                                          	// This member is required.
                                                                                          	ConfigurationId *string
                                                                                          
                                                                                          	// The maximum number of configurations that Amazon MQ can return per page (20 by
                                                                                          	// default). This value must be an integer from 5 to 100.
                                                                                          	MaxResults int32
                                                                                          
                                                                                          	// The token that specifies the next page of results Amazon MQ should return. To
                                                                                          	// request the first page, leave nextToken empty.
                                                                                          	NextToken *string
                                                                                          }

                                                                                          type ListConfigurationRevisionsOutput

                                                                                          type ListConfigurationRevisionsOutput struct {
                                                                                          
                                                                                          	// The unique ID that Amazon MQ generates for the configuration.
                                                                                          	ConfigurationId *string
                                                                                          
                                                                                          	// The maximum number of configuration revisions that can be returned per page (20
                                                                                          	// by default). This value must be an integer from 5 to 100.
                                                                                          	MaxResults int32
                                                                                          
                                                                                          	// The token that specifies the next page of results Amazon MQ should return. To
                                                                                          	// request the first page, leave nextToken empty.
                                                                                          	NextToken *string
                                                                                          
                                                                                          	// The list of all revisions for the specified configuration.
                                                                                          	Revisions []types.ConfigurationRevision
                                                                                          
                                                                                          	// Metadata pertaining to the operation's result.
                                                                                          	ResultMetadata middleware.Metadata
                                                                                          }

                                                                                          type ListConfigurationsInput

                                                                                          type ListConfigurationsInput struct {
                                                                                          
                                                                                          	// The maximum number of configurations that Amazon MQ can return per page (20 by
                                                                                          	// default). This value must be an integer from 5 to 100.
                                                                                          	MaxResults int32
                                                                                          
                                                                                          	// The token that specifies the next page of results Amazon MQ should return. To
                                                                                          	// request the first page, leave nextToken empty.
                                                                                          	NextToken *string
                                                                                          }

                                                                                          type ListConfigurationsOutput

                                                                                          type ListConfigurationsOutput struct {
                                                                                          
                                                                                          	// The list of all revisions for the specified configuration.
                                                                                          	Configurations []types.Configuration
                                                                                          
                                                                                          	// The maximum number of configurations that Amazon MQ can return per page (20 by
                                                                                          	// default). This value must be an integer from 5 to 100.
                                                                                          	MaxResults int32
                                                                                          
                                                                                          	// The token that specifies the next page of results Amazon MQ should return. To
                                                                                          	// request the first page, leave nextToken empty.
                                                                                          	NextToken *string
                                                                                          
                                                                                          	// Metadata pertaining to the operation's result.
                                                                                          	ResultMetadata middleware.Metadata
                                                                                          }

                                                                                          type ListTagsInput

                                                                                          type ListTagsInput struct {
                                                                                          
                                                                                          	// The Amazon Resource Name (ARN) of the resource tag.
                                                                                          	//
                                                                                          	// This member is required.
                                                                                          	ResourceArn *string
                                                                                          }

                                                                                          type ListTagsOutput

                                                                                          type ListTagsOutput struct {
                                                                                          
                                                                                          	// The key-value pair for the resource tag.
                                                                                          	Tags map[string]string
                                                                                          
                                                                                          	// Metadata pertaining to the operation's result.
                                                                                          	ResultMetadata middleware.Metadata
                                                                                          }

                                                                                          type ListUsersInput

                                                                                          type ListUsersInput struct {
                                                                                          
                                                                                          	// The unique ID that Amazon MQ generates for the broker.
                                                                                          	//
                                                                                          	// This member is required.
                                                                                          	BrokerId *string
                                                                                          
                                                                                          	// The maximum number of ActiveMQ users that can be returned per page (20 by
                                                                                          	// default). This value must be an integer from 5 to 100.
                                                                                          	MaxResults int32
                                                                                          
                                                                                          	// The token that specifies the next page of results Amazon MQ should return. To
                                                                                          	// request the first page, leave nextToken empty.
                                                                                          	NextToken *string
                                                                                          }

                                                                                          type ListUsersOutput

                                                                                          type ListUsersOutput struct {
                                                                                          
                                                                                          	// Required. The unique ID that Amazon MQ generates for the broker.
                                                                                          	BrokerId *string
                                                                                          
                                                                                          	// Required. The maximum number of ActiveMQ users that can be returned per page (20
                                                                                          	// by default). This value must be an integer from 5 to 100.
                                                                                          	MaxResults int32
                                                                                          
                                                                                          	// The token that specifies the next page of results Amazon MQ should return. To
                                                                                          	// request the first page, leave nextToken empty.
                                                                                          	NextToken *string
                                                                                          
                                                                                          	// Required. The list of all ActiveMQ usernames for the specified broker.
                                                                                          	Users []types.UserSummary
                                                                                          
                                                                                          	// Metadata pertaining to the operation's result.
                                                                                          	ResultMetadata middleware.Metadata
                                                                                          }

                                                                                          type Options

                                                                                          type Options struct {
                                                                                          	// Set of options to modify how an operation is invoked. These apply to all
                                                                                          	// operations invoked for this client. Use functional options on operation call to
                                                                                          	// modify this list for per operation behavior.
                                                                                          	APIOptions []func(*middleware.Stack) error
                                                                                          
                                                                                          	// Configures the events that will be sent to the configured logger.
                                                                                          	ClientLogMode aws.ClientLogMode
                                                                                          
                                                                                          	// The credentials object to use when signing requests.
                                                                                          	Credentials aws.CredentialsProvider
                                                                                          
                                                                                          	// The endpoint options to be used when attempting to resolve an endpoint.
                                                                                          	EndpointOptions EndpointResolverOptions
                                                                                          
                                                                                          	// The service endpoint resolver.
                                                                                          	EndpointResolver EndpointResolver
                                                                                          
                                                                                          	// Signature Version 4 (SigV4) Signer
                                                                                          	HTTPSignerV4 HTTPSignerV4
                                                                                          
                                                                                          	// Provides idempotency tokens values that will be automatically populated into
                                                                                          	// idempotent API operations.
                                                                                          	IdempotencyTokenProvider IdempotencyTokenProvider
                                                                                          
                                                                                          	// The logger writer interface to write logging messages to.
                                                                                          	Logger logging.Logger
                                                                                          
                                                                                          	// The region to send requests to. (Required)
                                                                                          	Region string
                                                                                          
                                                                                          	// Retryer guides how HTTP requests should be retried in case of recoverable
                                                                                          	// failures. When nil the API client will use a default retryer.
                                                                                          	Retryer aws.Retryer
                                                                                          
                                                                                          	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
                                                                                          	// implementation if nil.
                                                                                          	HTTPClient HTTPClient
                                                                                          }

                                                                                          func (Options) Copy

                                                                                          func (o Options) Copy() Options

                                                                                            Copy creates a clone where the APIOptions list is deep copied.

                                                                                            type RebootBrokerInput

                                                                                            type RebootBrokerInput struct {
                                                                                            
                                                                                            	// The unique ID that Amazon MQ generates for the broker.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	BrokerId *string
                                                                                            }

                                                                                            type RebootBrokerOutput

                                                                                            type RebootBrokerOutput struct {
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type ResolveEndpoint

                                                                                            type ResolveEndpoint struct {
                                                                                            	Resolver EndpointResolver
                                                                                            	Options  EndpointResolverOptions
                                                                                            }

                                                                                            func (*ResolveEndpoint) HandleSerialize

                                                                                            func (*ResolveEndpoint) ID

                                                                                            func (*ResolveEndpoint) ID() string

                                                                                            type UpdateBrokerInput

                                                                                            type UpdateBrokerInput struct {
                                                                                            
                                                                                            	// The unique ID that Amazon MQ generates for the broker.
                                                                                            	//
                                                                                            	// This member is required.
                                                                                            	BrokerId *string
                                                                                            
                                                                                            	// The authentication strategy used to secure the broker.
                                                                                            	AuthenticationStrategy types.AuthenticationStrategy
                                                                                            
                                                                                            	// Enables automatic upgrades to new minor versions for brokers, as Apache releases
                                                                                            	// the versions. The automatic upgrades occur during the maintenance window of the
                                                                                            	// broker or after a manual broker reboot.
                                                                                            	AutoMinorVersionUpgrade bool
                                                                                            
                                                                                            	// A list of information about the configuration.
                                                                                            	Configuration *types.ConfigurationId
                                                                                            
                                                                                            	// The version of the broker engine. For a list of supported engine versions, see
                                                                                            	// https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/broker-engine.html
                                                                                            	EngineVersion *string
                                                                                            
                                                                                            	// The host instance type of the broker to upgrade to. For a list of supported
                                                                                            	// instance types, see
                                                                                            	// https://docs.aws.amazon.com/amazon-mq/latest/developer-guide//broker.html#broker-instance-types
                                                                                            	HostInstanceType *string
                                                                                            
                                                                                            	// The metadata of the LDAP server used to authenticate and authorize connections
                                                                                            	// to the broker.
                                                                                            	LdapServerMetadata *types.LdapServerMetadataInput
                                                                                            
                                                                                            	// Enables Amazon CloudWatch logging for brokers.
                                                                                            	Logs *types.Logs
                                                                                            
                                                                                            	// The list of security groups (1 minimum, 5 maximum) that authorizes connections
                                                                                            	// to brokers.
                                                                                            	SecurityGroups []string
                                                                                            }

                                                                                              Updates the broker using the specified properties.

                                                                                              type UpdateBrokerOutput

                                                                                              type UpdateBrokerOutput struct {
                                                                                              
                                                                                              	// The authentication strategy used to secure the broker.
                                                                                              	AuthenticationStrategy types.AuthenticationStrategy
                                                                                              
                                                                                              	// The new value of automatic upgrades to new minor version for brokers.
                                                                                              	AutoMinorVersionUpgrade bool
                                                                                              
                                                                                              	// Required. The unique ID that Amazon MQ generates for the broker.
                                                                                              	BrokerId *string
                                                                                              
                                                                                              	// The ID of the updated configuration.
                                                                                              	Configuration *types.ConfigurationId
                                                                                              
                                                                                              	// The version of the broker engine to upgrade to. For a list of supported engine
                                                                                              	// versions, see
                                                                                              	// https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/broker-engine.html
                                                                                              	EngineVersion *string
                                                                                              
                                                                                              	// The host instance type of the broker to upgrade to. For a list of supported
                                                                                              	// instance types, see
                                                                                              	// https://docs.aws.amazon.com/amazon-mq/latest/developer-guide//broker.html#broker-instance-types
                                                                                              	HostInstanceType *string
                                                                                              
                                                                                              	// The metadata of the LDAP server used to authenticate and authorize connections
                                                                                              	// to the broker.
                                                                                              	LdapServerMetadata *types.LdapServerMetadataOutput
                                                                                              
                                                                                              	// The list of information about logs to be enabled for the specified broker.
                                                                                              	Logs *types.Logs
                                                                                              
                                                                                              	// The list of security groups (1 minimum, 5 maximum) that authorizes connections
                                                                                              	// to brokers.
                                                                                              	SecurityGroups []string
                                                                                              
                                                                                              	// Metadata pertaining to the operation's result.
                                                                                              	ResultMetadata middleware.Metadata
                                                                                              }

                                                                                              type UpdateConfigurationInput

                                                                                              type UpdateConfigurationInput struct {
                                                                                              
                                                                                              	// The unique ID that Amazon MQ generates for the configuration.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	ConfigurationId *string
                                                                                              
                                                                                              	// Required. The base64-encoded XML configuration.
                                                                                              	Data *string
                                                                                              
                                                                                              	// The description of the configuration.
                                                                                              	Description *string
                                                                                              }

                                                                                                Updates the specified configuration.

                                                                                                type UpdateConfigurationOutput

                                                                                                type UpdateConfigurationOutput struct {
                                                                                                
                                                                                                	// Required. The Amazon Resource Name (ARN) of the configuration.
                                                                                                	Arn *string
                                                                                                
                                                                                                	// Required. The date and time of the configuration.
                                                                                                	Created *time.Time
                                                                                                
                                                                                                	// Required. The unique ID that Amazon MQ generates for the configuration.
                                                                                                	Id *string
                                                                                                
                                                                                                	// The latest revision of the configuration.
                                                                                                	LatestRevision *types.ConfigurationRevision
                                                                                                
                                                                                                	// Required. The name of the configuration. This value can contain only
                                                                                                	// alphanumeric characters, dashes, periods, underscores, and tildes (- . _ ~).
                                                                                                	// This value must be 1-150 characters long.
                                                                                                	Name *string
                                                                                                
                                                                                                	// The list of the first 20 warnings about the configuration XML elements or
                                                                                                	// attributes that were sanitized.
                                                                                                	Warnings []types.SanitizationWarning
                                                                                                
                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                	ResultMetadata middleware.Metadata
                                                                                                }

                                                                                                type UpdateUserInput

                                                                                                type UpdateUserInput struct {
                                                                                                
                                                                                                	// The unique ID that Amazon MQ generates for the broker.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	BrokerId *string
                                                                                                
                                                                                                	// Required. The username of the ActiveMQ user. This value can contain only
                                                                                                	// alphanumeric characters, dashes, periods, underscores, and tildes (- . _ ~).
                                                                                                	// This value must be 2-100 characters long.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	Username *string
                                                                                                
                                                                                                	// Enables access to the the ActiveMQ Web Console for the ActiveMQ user.
                                                                                                	ConsoleAccess bool
                                                                                                
                                                                                                	// The list of groups (20 maximum) to which the ActiveMQ user belongs. This value
                                                                                                	// can contain only alphanumeric characters, dashes, periods, underscores, and
                                                                                                	// tildes (- . _ ~). This value must be 2-100 characters long.
                                                                                                	Groups []string
                                                                                                
                                                                                                	// The password of the user. This value must be at least 12 characters long, must
                                                                                                	// contain at least 4 unique characters, and must not contain commas.
                                                                                                	Password *string
                                                                                                }

                                                                                                  Updates the information for an ActiveMQ user.

                                                                                                  type UpdateUserOutput

                                                                                                  type UpdateUserOutput struct {
                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                  }

                                                                                                  Directories

                                                                                                  Path Synopsis
                                                                                                  internal