Documentation

Overview

    Package schemas provides the API client, operations, and parameter types for Schemas.

    Amazon EventBridge Schema Registry

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2019-12-02"
    View Source
    const ServiceID = "schemas"

    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 Schemas.

            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) CreateDiscoverer

                func (c *Client) CreateDiscoverer(ctx context.Context, params *CreateDiscovererInput, optFns ...func(*Options)) (*CreateDiscovererOutput, error)

                  Creates a discoverer.

                  func (*Client) CreateRegistry

                  func (c *Client) CreateRegistry(ctx context.Context, params *CreateRegistryInput, optFns ...func(*Options)) (*CreateRegistryOutput, error)

                    Creates a registry.

                    func (*Client) CreateSchema

                    func (c *Client) CreateSchema(ctx context.Context, params *CreateSchemaInput, optFns ...func(*Options)) (*CreateSchemaOutput, error)

                      Creates a schema definition. Inactive schemas will be deleted after two years.

                      func (*Client) DeleteDiscoverer

                      func (c *Client) DeleteDiscoverer(ctx context.Context, params *DeleteDiscovererInput, optFns ...func(*Options)) (*DeleteDiscovererOutput, error)

                        Deletes a discoverer.

                        func (*Client) DeleteRegistry

                        func (c *Client) DeleteRegistry(ctx context.Context, params *DeleteRegistryInput, optFns ...func(*Options)) (*DeleteRegistryOutput, error)

                          Deletes a Registry.

                          func (*Client) DeleteResourcePolicy

                          func (c *Client) DeleteResourcePolicy(ctx context.Context, params *DeleteResourcePolicyInput, optFns ...func(*Options)) (*DeleteResourcePolicyOutput, error)

                            Delete the resource-based policy attached to the specified registry.

                            func (*Client) DeleteSchema

                            func (c *Client) DeleteSchema(ctx context.Context, params *DeleteSchemaInput, optFns ...func(*Options)) (*DeleteSchemaOutput, error)

                              Delete a schema definition.

                              func (*Client) DeleteSchemaVersion

                              func (c *Client) DeleteSchemaVersion(ctx context.Context, params *DeleteSchemaVersionInput, optFns ...func(*Options)) (*DeleteSchemaVersionOutput, error)

                                Delete the schema version definition

                                func (*Client) DescribeCodeBinding

                                func (c *Client) DescribeCodeBinding(ctx context.Context, params *DescribeCodeBindingInput, optFns ...func(*Options)) (*DescribeCodeBindingOutput, error)

                                  Describe the code binding URI.

                                  func (*Client) DescribeDiscoverer

                                  func (c *Client) DescribeDiscoverer(ctx context.Context, params *DescribeDiscovererInput, optFns ...func(*Options)) (*DescribeDiscovererOutput, error)

                                    Describes the discoverer.

                                    func (*Client) DescribeRegistry

                                    func (c *Client) DescribeRegistry(ctx context.Context, params *DescribeRegistryInput, optFns ...func(*Options)) (*DescribeRegistryOutput, error)

                                      Describes the registry.

                                      func (*Client) DescribeSchema

                                      func (c *Client) DescribeSchema(ctx context.Context, params *DescribeSchemaInput, optFns ...func(*Options)) (*DescribeSchemaOutput, error)

                                        Retrieve the schema definition.

                                        func (*Client) ExportSchema

                                        func (c *Client) ExportSchema(ctx context.Context, params *ExportSchemaInput, optFns ...func(*Options)) (*ExportSchemaOutput, error)

                                        func (*Client) GetCodeBindingSource

                                        func (c *Client) GetCodeBindingSource(ctx context.Context, params *GetCodeBindingSourceInput, optFns ...func(*Options)) (*GetCodeBindingSourceOutput, error)

                                          Get the code binding source URI.

                                          func (*Client) GetDiscoveredSchema

                                          func (c *Client) GetDiscoveredSchema(ctx context.Context, params *GetDiscoveredSchemaInput, optFns ...func(*Options)) (*GetDiscoveredSchemaOutput, error)

                                            Get the discovered schema that was generated based on sampled events.

                                            func (*Client) GetResourcePolicy

                                            func (c *Client) GetResourcePolicy(ctx context.Context, params *GetResourcePolicyInput, optFns ...func(*Options)) (*GetResourcePolicyOutput, error)

                                              Retrieves the resource-based policy attached to a given registry.

                                              func (*Client) ListDiscoverers

                                              func (c *Client) ListDiscoverers(ctx context.Context, params *ListDiscoverersInput, optFns ...func(*Options)) (*ListDiscoverersOutput, error)

                                                List the discoverers.

                                                func (*Client) ListRegistries

                                                func (c *Client) ListRegistries(ctx context.Context, params *ListRegistriesInput, optFns ...func(*Options)) (*ListRegistriesOutput, error)

                                                  List the registries.

                                                  func (*Client) ListSchemaVersions

                                                  func (c *Client) ListSchemaVersions(ctx context.Context, params *ListSchemaVersionsInput, optFns ...func(*Options)) (*ListSchemaVersionsOutput, error)

                                                    Provides a list of the schema versions and related information.

                                                    func (*Client) ListSchemas

                                                    func (c *Client) ListSchemas(ctx context.Context, params *ListSchemasInput, optFns ...func(*Options)) (*ListSchemasOutput, error)

                                                      List the schemas.

                                                      func (*Client) ListTagsForResource

                                                      func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error)

                                                        Get tags for resource.

                                                        func (*Client) PutCodeBinding

                                                        func (c *Client) PutCodeBinding(ctx context.Context, params *PutCodeBindingInput, optFns ...func(*Options)) (*PutCodeBindingOutput, error)

                                                          Put code binding URI

                                                          func (*Client) PutResourcePolicy

                                                          func (c *Client) PutResourcePolicy(ctx context.Context, params *PutResourcePolicyInput, optFns ...func(*Options)) (*PutResourcePolicyOutput, error)

                                                            The name of the policy.

                                                            func (*Client) SearchSchemas

                                                            func (c *Client) SearchSchemas(ctx context.Context, params *SearchSchemasInput, optFns ...func(*Options)) (*SearchSchemasOutput, error)

                                                              Search the schemas

                                                              func (*Client) StartDiscoverer

                                                              func (c *Client) StartDiscoverer(ctx context.Context, params *StartDiscovererInput, optFns ...func(*Options)) (*StartDiscovererOutput, error)

                                                                Starts the discoverer

                                                                func (*Client) StopDiscoverer

                                                                func (c *Client) StopDiscoverer(ctx context.Context, params *StopDiscovererInput, optFns ...func(*Options)) (*StopDiscovererOutput, error)

                                                                  Stops the discoverer

                                                                  func (*Client) TagResource

                                                                  func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error)

                                                                    Add tags to a resource.

                                                                    func (*Client) UntagResource

                                                                    func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error)

                                                                      Removes tags from a resource.

                                                                      func (*Client) UpdateDiscoverer

                                                                      func (c *Client) UpdateDiscoverer(ctx context.Context, params *UpdateDiscovererInput, optFns ...func(*Options)) (*UpdateDiscovererOutput, error)

                                                                        Updates the discoverer

                                                                        func (*Client) UpdateRegistry

                                                                        func (c *Client) UpdateRegistry(ctx context.Context, params *UpdateRegistryInput, optFns ...func(*Options)) (*UpdateRegistryOutput, error)

                                                                          Updates a registry.

                                                                          func (*Client) UpdateSchema

                                                                          func (c *Client) UpdateSchema(ctx context.Context, params *UpdateSchemaInput, optFns ...func(*Options)) (*UpdateSchemaOutput, error)

                                                                            Updates the schema definition Inactive schemas will be deleted after two years.

                                                                            type CodeBindingExistsWaiter

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

                                                                              CodeBindingExistsWaiter defines the waiters for CodeBindingExists

                                                                              func NewCodeBindingExistsWaiter

                                                                              func NewCodeBindingExistsWaiter(client DescribeCodeBindingAPIClient, optFns ...func(*CodeBindingExistsWaiterOptions)) *CodeBindingExistsWaiter

                                                                                NewCodeBindingExistsWaiter constructs a CodeBindingExistsWaiter.

                                                                                func (*CodeBindingExistsWaiter) Wait

                                                                                  Wait calls the waiter function for CodeBindingExists waiter. The maxWaitDur is the maximum wait duration the waiter will wait. The maxWaitDur is required and must be greater than zero.

                                                                                  type CodeBindingExistsWaiterOptions

                                                                                  type CodeBindingExistsWaiterOptions 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
                                                                                  
                                                                                  	// MinDelay is the minimum amount of time to delay between retries. If unset,
                                                                                  	// CodeBindingExistsWaiter will use default minimum delay of 2 seconds. Note that
                                                                                  	// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
                                                                                  	MinDelay time.Duration
                                                                                  
                                                                                  	// MaxDelay is the maximum amount of time to delay between retries. If unset or set
                                                                                  	// to zero, CodeBindingExistsWaiter will use default max delay of 120 seconds. Note
                                                                                  	// that MaxDelay must resolve to value greater than or equal to the MinDelay.
                                                                                  	MaxDelay time.Duration
                                                                                  
                                                                                  	// LogWaitAttempts is used to enable logging for waiter retry attempts
                                                                                  	LogWaitAttempts bool
                                                                                  
                                                                                  	// Retryable is function that can be used to override the service defined
                                                                                  	// waiter-behavior based on operation output, or returned error. This function is
                                                                                  	// used by the waiter to decide if a state is retryable or a terminal state. By
                                                                                  	// default service-modeled logic will populate this option. This option can thus be
                                                                                  	// used to define a custom waiter state with fall-back to service-modeled waiter
                                                                                  	// state mutators.The function returns an error in case of a failure state. In case
                                                                                  	// of retry state, this function returns a bool value of true and nil error, while
                                                                                  	// in case of success it returns a bool value of false and nil error.
                                                                                  	Retryable func(context.Context, *DescribeCodeBindingInput, *DescribeCodeBindingOutput, error) (bool, error)
                                                                                  }

                                                                                    CodeBindingExistsWaiterOptions are waiter options for CodeBindingExistsWaiter

                                                                                    type CreateDiscovererInput

                                                                                    type CreateDiscovererInput struct {
                                                                                    
                                                                                    	// The ARN of the event bus.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	SourceArn *string
                                                                                    
                                                                                    	// A description for the discoverer.
                                                                                    	Description *string
                                                                                    
                                                                                    	// Tags associated with the resource.
                                                                                    	Tags map[string]string
                                                                                    }

                                                                                    type CreateDiscovererOutput

                                                                                    type CreateDiscovererOutput struct {
                                                                                    
                                                                                    	// The description of the discoverer.
                                                                                    	Description *string
                                                                                    
                                                                                    	// The ARN of the discoverer.
                                                                                    	DiscovererArn *string
                                                                                    
                                                                                    	// The ID of the discoverer.
                                                                                    	DiscovererId *string
                                                                                    
                                                                                    	// The ARN of the event bus.
                                                                                    	SourceArn *string
                                                                                    
                                                                                    	// The state of the discoverer.
                                                                                    	State types.DiscovererState
                                                                                    
                                                                                    	// Tags associated with the resource.
                                                                                    	Tags map[string]string
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type CreateRegistryInput

                                                                                    type CreateRegistryInput struct {
                                                                                    
                                                                                    	// The name of the registry.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	RegistryName *string
                                                                                    
                                                                                    	// A description of the registry to be created.
                                                                                    	Description *string
                                                                                    
                                                                                    	// Tags to associate with the registry.
                                                                                    	Tags map[string]string
                                                                                    }

                                                                                    type CreateRegistryOutput

                                                                                    type CreateRegistryOutput struct {
                                                                                    
                                                                                    	// The description of the registry.
                                                                                    	Description *string
                                                                                    
                                                                                    	// The ARN of the registry.
                                                                                    	RegistryArn *string
                                                                                    
                                                                                    	// The name of the registry.
                                                                                    	RegistryName *string
                                                                                    
                                                                                    	// Tags associated with the registry.
                                                                                    	Tags map[string]string
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type CreateSchemaInput

                                                                                    type CreateSchemaInput struct {
                                                                                    
                                                                                    	// The source of the schema definition.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	Content *string
                                                                                    
                                                                                    	// The name of the registry.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	RegistryName *string
                                                                                    
                                                                                    	// The name of the schema.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	SchemaName *string
                                                                                    
                                                                                    	// The type of schema.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	Type types.Type
                                                                                    
                                                                                    	// A description of the schema.
                                                                                    	Description *string
                                                                                    
                                                                                    	// Tags associated with the schema.
                                                                                    	Tags map[string]string
                                                                                    }

                                                                                    type CreateSchemaOutput

                                                                                    type CreateSchemaOutput struct {
                                                                                    
                                                                                    	// The description of the schema.
                                                                                    	Description *string
                                                                                    
                                                                                    	// The date and time that schema was modified.
                                                                                    	LastModified *time.Time
                                                                                    
                                                                                    	// The ARN of the schema.
                                                                                    	SchemaArn *string
                                                                                    
                                                                                    	// The name of the schema.
                                                                                    	SchemaName *string
                                                                                    
                                                                                    	// The version number of the schema
                                                                                    	SchemaVersion *string
                                                                                    
                                                                                    	// Key-value pairs associated with a resource.
                                                                                    	Tags map[string]string
                                                                                    
                                                                                    	// The type of the schema.
                                                                                    	Type *string
                                                                                    
                                                                                    	// The date the schema version was created.
                                                                                    	VersionCreatedDate *time.Time
                                                                                    
                                                                                    	// Metadata pertaining to the operation's result.
                                                                                    	ResultMetadata middleware.Metadata
                                                                                    }

                                                                                    type DeleteDiscovererInput

                                                                                    type DeleteDiscovererInput struct {
                                                                                    
                                                                                    	// The ID of the discoverer.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	DiscovererId *string
                                                                                    }

                                                                                    type DeleteDiscovererOutput

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

                                                                                    type DeleteRegistryInput

                                                                                    type DeleteRegistryInput struct {
                                                                                    
                                                                                    	// The name of the registry.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	RegistryName *string
                                                                                    }

                                                                                    type DeleteRegistryOutput

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

                                                                                    type DeleteResourcePolicyInput

                                                                                    type DeleteResourcePolicyInput struct {
                                                                                    
                                                                                    	// The name of the registry.
                                                                                    	RegistryName *string
                                                                                    }

                                                                                    type DeleteResourcePolicyOutput

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

                                                                                    type DeleteSchemaInput

                                                                                    type DeleteSchemaInput struct {
                                                                                    
                                                                                    	// The name of the registry.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	RegistryName *string
                                                                                    
                                                                                    	// The name of the schema.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	SchemaName *string
                                                                                    }

                                                                                    type DeleteSchemaOutput

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

                                                                                    type DeleteSchemaVersionInput

                                                                                    type DeleteSchemaVersionInput struct {
                                                                                    
                                                                                    	// The name of the registry.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	RegistryName *string
                                                                                    
                                                                                    	// The name of the schema.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	SchemaName *string
                                                                                    
                                                                                    	// The version number of the schema
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	SchemaVersion *string
                                                                                    }

                                                                                    type DeleteSchemaVersionOutput

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

                                                                                    type DescribeCodeBindingAPIClient

                                                                                    type DescribeCodeBindingAPIClient interface {
                                                                                    	DescribeCodeBinding(context.Context, *DescribeCodeBindingInput, ...func(*Options)) (*DescribeCodeBindingOutput, error)
                                                                                    }

                                                                                      DescribeCodeBindingAPIClient is a client that implements the DescribeCodeBinding operation.

                                                                                      type DescribeCodeBindingInput

                                                                                      type DescribeCodeBindingInput struct {
                                                                                      
                                                                                      	// The language of the code binding.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	Language *string
                                                                                      
                                                                                      	// The name of the registry.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	RegistryName *string
                                                                                      
                                                                                      	// The name of the schema.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	SchemaName *string
                                                                                      
                                                                                      	// Specifying this limits the results to only this schema version.
                                                                                      	SchemaVersion *string
                                                                                      }

                                                                                      type DescribeCodeBindingOutput

                                                                                      type DescribeCodeBindingOutput struct {
                                                                                      
                                                                                      	// The time and date that the code binding was created.
                                                                                      	CreationDate *time.Time
                                                                                      
                                                                                      	// The date and time that code bindings were modified.
                                                                                      	LastModified *time.Time
                                                                                      
                                                                                      	// The version number of the schema.
                                                                                      	SchemaVersion *string
                                                                                      
                                                                                      	// The current status of code binding generation.
                                                                                      	Status types.CodeGenerationStatus
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type DescribeDiscovererInput

                                                                                      type DescribeDiscovererInput struct {
                                                                                      
                                                                                      	// The ID of the discoverer.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	DiscovererId *string
                                                                                      }

                                                                                      type DescribeDiscovererOutput

                                                                                      type DescribeDiscovererOutput struct {
                                                                                      
                                                                                      	// The description of the discoverer.
                                                                                      	Description *string
                                                                                      
                                                                                      	// The ARN of the discoverer.
                                                                                      	DiscovererArn *string
                                                                                      
                                                                                      	// The ID of the discoverer.
                                                                                      	DiscovererId *string
                                                                                      
                                                                                      	// The ARN of the event bus.
                                                                                      	SourceArn *string
                                                                                      
                                                                                      	// The state of the discoverer.
                                                                                      	State types.DiscovererState
                                                                                      
                                                                                      	// Tags associated with the resource.
                                                                                      	Tags map[string]string
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type DescribeRegistryInput

                                                                                      type DescribeRegistryInput struct {
                                                                                      
                                                                                      	// The name of the registry.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	RegistryName *string
                                                                                      }

                                                                                      type DescribeRegistryOutput

                                                                                      type DescribeRegistryOutput struct {
                                                                                      
                                                                                      	// The description of the registry.
                                                                                      	Description *string
                                                                                      
                                                                                      	// The ARN of the registry.
                                                                                      	RegistryArn *string
                                                                                      
                                                                                      	// The name of the registry.
                                                                                      	RegistryName *string
                                                                                      
                                                                                      	// Tags associated with the registry.
                                                                                      	Tags map[string]string
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type DescribeSchemaInput

                                                                                      type DescribeSchemaInput struct {
                                                                                      
                                                                                      	// The name of the registry.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	RegistryName *string
                                                                                      
                                                                                      	// The name of the schema.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	SchemaName *string
                                                                                      
                                                                                      	// Specifying this limits the results to only this schema version.
                                                                                      	SchemaVersion *string
                                                                                      }

                                                                                      type DescribeSchemaOutput

                                                                                      type DescribeSchemaOutput struct {
                                                                                      
                                                                                      	// The source of the schema definition.
                                                                                      	Content *string
                                                                                      
                                                                                      	// The description of the schema.
                                                                                      	Description *string
                                                                                      
                                                                                      	// The date and time that schema was modified.
                                                                                      	LastModified *time.Time
                                                                                      
                                                                                      	// The ARN of the schema.
                                                                                      	SchemaArn *string
                                                                                      
                                                                                      	// The name of the schema.
                                                                                      	SchemaName *string
                                                                                      
                                                                                      	// The version number of the schema
                                                                                      	SchemaVersion *string
                                                                                      
                                                                                      	// Tags associated with the resource.
                                                                                      	Tags map[string]string
                                                                                      
                                                                                      	// The type of the schema.
                                                                                      	Type *string
                                                                                      
                                                                                      	// The date the schema version was created.
                                                                                      	VersionCreatedDate *time.Time
                                                                                      
                                                                                      	// 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 ExportSchemaInput

                                                                                              type ExportSchemaInput struct {
                                                                                              
                                                                                              	// The name of the registry.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	RegistryName *string
                                                                                              
                                                                                              	// The name of the schema.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	SchemaName *string
                                                                                              
                                                                                              	// This member is required.
                                                                                              	Type *string
                                                                                              
                                                                                              	// Specifying this limits the results to only this schema version.
                                                                                              	SchemaVersion *string
                                                                                              }

                                                                                              type ExportSchemaOutput

                                                                                              type ExportSchemaOutput struct {
                                                                                              	Content *string
                                                                                              
                                                                                              	SchemaArn *string
                                                                                              
                                                                                              	SchemaName *string
                                                                                              
                                                                                              	SchemaVersion *string
                                                                                              
                                                                                              	Type *string
                                                                                              
                                                                                              	// Metadata pertaining to the operation's result.
                                                                                              	ResultMetadata middleware.Metadata
                                                                                              }

                                                                                              type GetCodeBindingSourceInput

                                                                                              type GetCodeBindingSourceInput struct {
                                                                                              
                                                                                              	// The language of the code binding.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	Language *string
                                                                                              
                                                                                              	// The name of the registry.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	RegistryName *string
                                                                                              
                                                                                              	// The name of the schema.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	SchemaName *string
                                                                                              
                                                                                              	// Specifying this limits the results to only this schema version.
                                                                                              	SchemaVersion *string
                                                                                              }

                                                                                              type GetCodeBindingSourceOutput

                                                                                              type GetCodeBindingSourceOutput struct {
                                                                                              	Body []byte
                                                                                              
                                                                                              	// Metadata pertaining to the operation's result.
                                                                                              	ResultMetadata middleware.Metadata
                                                                                              }

                                                                                              type GetDiscoveredSchemaInput

                                                                                              type GetDiscoveredSchemaInput struct {
                                                                                              
                                                                                              	// An array of strings where each string is a JSON event. These are the events that
                                                                                              	// were used to generate the schema. The array includes a single type of event and
                                                                                              	// has a maximum size of 10 events.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	Events []string
                                                                                              
                                                                                              	// The type of event.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	Type types.Type
                                                                                              }

                                                                                              type GetDiscoveredSchemaOutput

                                                                                              type GetDiscoveredSchemaOutput struct {
                                                                                              
                                                                                              	// The source of the schema definition.
                                                                                              	Content *string
                                                                                              
                                                                                              	// Metadata pertaining to the operation's result.
                                                                                              	ResultMetadata middleware.Metadata
                                                                                              }

                                                                                              type GetResourcePolicyInput

                                                                                              type GetResourcePolicyInput struct {
                                                                                              
                                                                                              	// The name of the registry.
                                                                                              	RegistryName *string
                                                                                              }

                                                                                              type GetResourcePolicyOutput

                                                                                              type GetResourcePolicyOutput struct {
                                                                                              
                                                                                              	// The resource-based policy.
                                                                                              	//
                                                                                              	// This value conforms to the media type: application/json
                                                                                              	Policy *string
                                                                                              
                                                                                              	// The revision ID.
                                                                                              	RevisionId *string
                                                                                              
                                                                                              	// Metadata pertaining to the operation's result.
                                                                                              	ResultMetadata middleware.Metadata
                                                                                              }

                                                                                              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 ListDiscoverersAPIClient

                                                                                                type ListDiscoverersAPIClient interface {
                                                                                                	ListDiscoverers(context.Context, *ListDiscoverersInput, ...func(*Options)) (*ListDiscoverersOutput, error)
                                                                                                }

                                                                                                  ListDiscoverersAPIClient is a client that implements the ListDiscoverers operation.

                                                                                                  type ListDiscoverersInput

                                                                                                  type ListDiscoverersInput struct {
                                                                                                  
                                                                                                  	// Specifying this limits the results to only those discoverer IDs that start with
                                                                                                  	// the specified prefix.
                                                                                                  	DiscovererIdPrefix *string
                                                                                                  
                                                                                                  	Limit int32
                                                                                                  
                                                                                                  	// The token that specifies the next page of results to return. To request the
                                                                                                  	// first page, leave NextToken empty. The token will expire in 24 hours, and cannot
                                                                                                  	// be shared with other accounts.
                                                                                                  	NextToken *string
                                                                                                  
                                                                                                  	// Specifying this limits the results to only those ARNs that start with the
                                                                                                  	// specified prefix.
                                                                                                  	SourceArnPrefix *string
                                                                                                  }

                                                                                                  type ListDiscoverersOutput

                                                                                                  type ListDiscoverersOutput struct {
                                                                                                  
                                                                                                  	// An array of DiscovererSummary information.
                                                                                                  	Discoverers []types.DiscovererSummary
                                                                                                  
                                                                                                  	// The token that specifies the next page of results to return. To request the
                                                                                                  	// first page, leave NextToken empty. The token will expire in 24 hours, and cannot
                                                                                                  	// be shared with other accounts.
                                                                                                  	NextToken *string
                                                                                                  
                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                  }

                                                                                                  type ListDiscoverersPaginator

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

                                                                                                    ListDiscoverersPaginator is a paginator for ListDiscoverers

                                                                                                    func NewListDiscoverersPaginator

                                                                                                    func NewListDiscoverersPaginator(client ListDiscoverersAPIClient, params *ListDiscoverersInput, optFns ...func(*ListDiscoverersPaginatorOptions)) *ListDiscoverersPaginator

                                                                                                      NewListDiscoverersPaginator returns a new ListDiscoverersPaginator

                                                                                                      func (*ListDiscoverersPaginator) HasMorePages

                                                                                                      func (p *ListDiscoverersPaginator) HasMorePages() bool

                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                        func (*ListDiscoverersPaginator) NextPage

                                                                                                        func (p *ListDiscoverersPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDiscoverersOutput, error)

                                                                                                          NextPage retrieves the next ListDiscoverers page.

                                                                                                          type ListDiscoverersPaginatorOptions

                                                                                                          type ListDiscoverersPaginatorOptions struct {
                                                                                                          	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
                                                                                                          }

                                                                                                            ListDiscoverersPaginatorOptions is the paginator options for ListDiscoverers

                                                                                                            type ListRegistriesAPIClient

                                                                                                            type ListRegistriesAPIClient interface {
                                                                                                            	ListRegistries(context.Context, *ListRegistriesInput, ...func(*Options)) (*ListRegistriesOutput, error)
                                                                                                            }

                                                                                                              ListRegistriesAPIClient is a client that implements the ListRegistries operation.

                                                                                                              type ListRegistriesInput

                                                                                                              type ListRegistriesInput struct {
                                                                                                              	Limit int32
                                                                                                              
                                                                                                              	// The token that specifies the next page of results to return. To request the
                                                                                                              	// first page, leave NextToken empty. The token will expire in 24 hours, and cannot
                                                                                                              	// be shared with other accounts.
                                                                                                              	NextToken *string
                                                                                                              
                                                                                                              	// Specifying this limits the results to only those registry names that start with
                                                                                                              	// the specified prefix.
                                                                                                              	RegistryNamePrefix *string
                                                                                                              
                                                                                                              	// Can be set to Local or AWS to limit responses to your custom registries, or the
                                                                                                              	// ones provided by AWS.
                                                                                                              	Scope *string
                                                                                                              }

                                                                                                              type ListRegistriesOutput

                                                                                                              type ListRegistriesOutput struct {
                                                                                                              
                                                                                                              	// The token that specifies the next page of results to return. To request the
                                                                                                              	// first page, leave NextToken empty. The token will expire in 24 hours, and cannot
                                                                                                              	// be shared with other accounts.
                                                                                                              	NextToken *string
                                                                                                              
                                                                                                              	// An array of registry summaries.
                                                                                                              	Registries []types.RegistrySummary
                                                                                                              
                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                              }

                                                                                                              type ListRegistriesPaginator

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

                                                                                                                ListRegistriesPaginator is a paginator for ListRegistries

                                                                                                                func NewListRegistriesPaginator

                                                                                                                func NewListRegistriesPaginator(client ListRegistriesAPIClient, params *ListRegistriesInput, optFns ...func(*ListRegistriesPaginatorOptions)) *ListRegistriesPaginator

                                                                                                                  NewListRegistriesPaginator returns a new ListRegistriesPaginator

                                                                                                                  func (*ListRegistriesPaginator) HasMorePages

                                                                                                                  func (p *ListRegistriesPaginator) HasMorePages() bool

                                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                    func (*ListRegistriesPaginator) NextPage

                                                                                                                    func (p *ListRegistriesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListRegistriesOutput, error)

                                                                                                                      NextPage retrieves the next ListRegistries page.

                                                                                                                      type ListRegistriesPaginatorOptions

                                                                                                                      type ListRegistriesPaginatorOptions struct {
                                                                                                                      	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
                                                                                                                      }

                                                                                                                        ListRegistriesPaginatorOptions is the paginator options for ListRegistries

                                                                                                                        type ListSchemaVersionsAPIClient

                                                                                                                        type ListSchemaVersionsAPIClient interface {
                                                                                                                        	ListSchemaVersions(context.Context, *ListSchemaVersionsInput, ...func(*Options)) (*ListSchemaVersionsOutput, error)
                                                                                                                        }

                                                                                                                          ListSchemaVersionsAPIClient is a client that implements the ListSchemaVersions operation.

                                                                                                                          type ListSchemaVersionsInput

                                                                                                                          type ListSchemaVersionsInput struct {
                                                                                                                          
                                                                                                                          	// The name of the registry.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	RegistryName *string
                                                                                                                          
                                                                                                                          	// The name of the schema.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	SchemaName *string
                                                                                                                          
                                                                                                                          	Limit int32
                                                                                                                          
                                                                                                                          	// The token that specifies the next page of results to return. To request the
                                                                                                                          	// first page, leave NextToken empty. The token will expire in 24 hours, and cannot
                                                                                                                          	// be shared with other accounts.
                                                                                                                          	NextToken *string
                                                                                                                          }

                                                                                                                          type ListSchemaVersionsOutput

                                                                                                                          type ListSchemaVersionsOutput struct {
                                                                                                                          
                                                                                                                          	// The token that specifies the next page of results to return. To request the
                                                                                                                          	// first page, leave NextToken empty. The token will expire in 24 hours, and cannot
                                                                                                                          	// be shared with other accounts.
                                                                                                                          	NextToken *string
                                                                                                                          
                                                                                                                          	// An array of schema version summaries.
                                                                                                                          	SchemaVersions []types.SchemaVersionSummary
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type ListSchemaVersionsPaginator

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

                                                                                                                            ListSchemaVersionsPaginator is a paginator for ListSchemaVersions

                                                                                                                            func NewListSchemaVersionsPaginator

                                                                                                                            func NewListSchemaVersionsPaginator(client ListSchemaVersionsAPIClient, params *ListSchemaVersionsInput, optFns ...func(*ListSchemaVersionsPaginatorOptions)) *ListSchemaVersionsPaginator

                                                                                                                              NewListSchemaVersionsPaginator returns a new ListSchemaVersionsPaginator

                                                                                                                              func (*ListSchemaVersionsPaginator) HasMorePages

                                                                                                                              func (p *ListSchemaVersionsPaginator) HasMorePages() bool

                                                                                                                                HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                func (*ListSchemaVersionsPaginator) NextPage

                                                                                                                                func (p *ListSchemaVersionsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListSchemaVersionsOutput, error)

                                                                                                                                  NextPage retrieves the next ListSchemaVersions page.

                                                                                                                                  type ListSchemaVersionsPaginatorOptions

                                                                                                                                  type ListSchemaVersionsPaginatorOptions struct {
                                                                                                                                  	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
                                                                                                                                  }

                                                                                                                                    ListSchemaVersionsPaginatorOptions is the paginator options for ListSchemaVersions

                                                                                                                                    type ListSchemasAPIClient

                                                                                                                                    type ListSchemasAPIClient interface {
                                                                                                                                    	ListSchemas(context.Context, *ListSchemasInput, ...func(*Options)) (*ListSchemasOutput, error)
                                                                                                                                    }

                                                                                                                                      ListSchemasAPIClient is a client that implements the ListSchemas operation.

                                                                                                                                      type ListSchemasInput

                                                                                                                                      type ListSchemasInput struct {
                                                                                                                                      
                                                                                                                                      	// The name of the registry.
                                                                                                                                      	//
                                                                                                                                      	// This member is required.
                                                                                                                                      	RegistryName *string
                                                                                                                                      
                                                                                                                                      	Limit int32
                                                                                                                                      
                                                                                                                                      	// The token that specifies the next page of results to return. To request the
                                                                                                                                      	// first page, leave NextToken empty. The token will expire in 24 hours, and cannot
                                                                                                                                      	// be shared with other accounts.
                                                                                                                                      	NextToken *string
                                                                                                                                      
                                                                                                                                      	// Specifying this limits the results to only those schema names that start with
                                                                                                                                      	// the specified prefix.
                                                                                                                                      	SchemaNamePrefix *string
                                                                                                                                      }

                                                                                                                                      type ListSchemasOutput

                                                                                                                                      type ListSchemasOutput struct {
                                                                                                                                      
                                                                                                                                      	// The token that specifies the next page of results to return. To request the
                                                                                                                                      	// first page, leave NextToken empty. The token will expire in 24 hours, and cannot
                                                                                                                                      	// be shared with other accounts.
                                                                                                                                      	NextToken *string
                                                                                                                                      
                                                                                                                                      	// An array of schema summaries.
                                                                                                                                      	Schemas []types.SchemaSummary
                                                                                                                                      
                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                      }

                                                                                                                                      type ListSchemasPaginator

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

                                                                                                                                        ListSchemasPaginator is a paginator for ListSchemas

                                                                                                                                        func NewListSchemasPaginator

                                                                                                                                        func NewListSchemasPaginator(client ListSchemasAPIClient, params *ListSchemasInput, optFns ...func(*ListSchemasPaginatorOptions)) *ListSchemasPaginator

                                                                                                                                          NewListSchemasPaginator returns a new ListSchemasPaginator

                                                                                                                                          func (*ListSchemasPaginator) HasMorePages

                                                                                                                                          func (p *ListSchemasPaginator) HasMorePages() bool

                                                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                            func (*ListSchemasPaginator) NextPage

                                                                                                                                            func (p *ListSchemasPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListSchemasOutput, error)

                                                                                                                                              NextPage retrieves the next ListSchemas page.

                                                                                                                                              type ListSchemasPaginatorOptions

                                                                                                                                              type ListSchemasPaginatorOptions struct {
                                                                                                                                              	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
                                                                                                                                              }

                                                                                                                                                ListSchemasPaginatorOptions is the paginator options for ListSchemas

                                                                                                                                                type ListTagsForResourceInput

                                                                                                                                                type ListTagsForResourceInput struct {
                                                                                                                                                
                                                                                                                                                	// The ARN of the resource.
                                                                                                                                                	//
                                                                                                                                                	// This member is required.
                                                                                                                                                	ResourceArn *string
                                                                                                                                                }

                                                                                                                                                type ListTagsForResourceOutput

                                                                                                                                                type ListTagsForResourceOutput struct {
                                                                                                                                                
                                                                                                                                                	// Key-value pairs associated with a resource.
                                                                                                                                                	Tags map[string]string
                                                                                                                                                
                                                                                                                                                	// 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 PutCodeBindingInput

                                                                                                                                                  type PutCodeBindingInput struct {
                                                                                                                                                  
                                                                                                                                                  	// The language of the code binding.
                                                                                                                                                  	//
                                                                                                                                                  	// This member is required.
                                                                                                                                                  	Language *string
                                                                                                                                                  
                                                                                                                                                  	// The name of the registry.
                                                                                                                                                  	//
                                                                                                                                                  	// This member is required.
                                                                                                                                                  	RegistryName *string
                                                                                                                                                  
                                                                                                                                                  	// The name of the schema.
                                                                                                                                                  	//
                                                                                                                                                  	// This member is required.
                                                                                                                                                  	SchemaName *string
                                                                                                                                                  
                                                                                                                                                  	// Specifying this limits the results to only this schema version.
                                                                                                                                                  	SchemaVersion *string
                                                                                                                                                  }

                                                                                                                                                  type PutCodeBindingOutput

                                                                                                                                                  type PutCodeBindingOutput struct {
                                                                                                                                                  
                                                                                                                                                  	// The time and date that the code binding was created.
                                                                                                                                                  	CreationDate *time.Time
                                                                                                                                                  
                                                                                                                                                  	// The date and time that code bindings were modified.
                                                                                                                                                  	LastModified *time.Time
                                                                                                                                                  
                                                                                                                                                  	// The version number of the schema.
                                                                                                                                                  	SchemaVersion *string
                                                                                                                                                  
                                                                                                                                                  	// The current status of code binding generation.
                                                                                                                                                  	Status types.CodeGenerationStatus
                                                                                                                                                  
                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                  }

                                                                                                                                                  type PutResourcePolicyInput

                                                                                                                                                  type PutResourcePolicyInput struct {
                                                                                                                                                  
                                                                                                                                                  	// The resource-based policy.
                                                                                                                                                  	//
                                                                                                                                                  	// This value conforms to the media type: application/json
                                                                                                                                                  	//
                                                                                                                                                  	// This member is required.
                                                                                                                                                  	Policy *string
                                                                                                                                                  
                                                                                                                                                  	// The name of the registry.
                                                                                                                                                  	RegistryName *string
                                                                                                                                                  
                                                                                                                                                  	// The revision ID of the policy.
                                                                                                                                                  	RevisionId *string
                                                                                                                                                  }

                                                                                                                                                    The name of the policy.

                                                                                                                                                    type PutResourcePolicyOutput

                                                                                                                                                    type PutResourcePolicyOutput struct {
                                                                                                                                                    
                                                                                                                                                    	// The resource-based policy.
                                                                                                                                                    	//
                                                                                                                                                    	// This value conforms to the media type: application/json
                                                                                                                                                    	Policy *string
                                                                                                                                                    
                                                                                                                                                    	// The revision ID of the policy.
                                                                                                                                                    	RevisionId *string
                                                                                                                                                    
                                                                                                                                                    	// 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 SearchSchemasAPIClient

                                                                                                                                                    type SearchSchemasAPIClient interface {
                                                                                                                                                    	SearchSchemas(context.Context, *SearchSchemasInput, ...func(*Options)) (*SearchSchemasOutput, error)
                                                                                                                                                    }

                                                                                                                                                      SearchSchemasAPIClient is a client that implements the SearchSchemas operation.

                                                                                                                                                      type SearchSchemasInput

                                                                                                                                                      type SearchSchemasInput struct {
                                                                                                                                                      
                                                                                                                                                      	// Specifying this limits the results to only schemas that include the provided
                                                                                                                                                      	// keywords.
                                                                                                                                                      	//
                                                                                                                                                      	// This member is required.
                                                                                                                                                      	Keywords *string
                                                                                                                                                      
                                                                                                                                                      	// The name of the registry.
                                                                                                                                                      	//
                                                                                                                                                      	// This member is required.
                                                                                                                                                      	RegistryName *string
                                                                                                                                                      
                                                                                                                                                      	Limit int32
                                                                                                                                                      
                                                                                                                                                      	// The token that specifies the next page of results to return. To request the
                                                                                                                                                      	// first page, leave NextToken empty. The token will expire in 24 hours, and cannot
                                                                                                                                                      	// be shared with other accounts.
                                                                                                                                                      	NextToken *string
                                                                                                                                                      }

                                                                                                                                                      type SearchSchemasOutput

                                                                                                                                                      type SearchSchemasOutput struct {
                                                                                                                                                      
                                                                                                                                                      	// The token that specifies the next page of results to return. To request the
                                                                                                                                                      	// first page, leave NextToken empty. The token will expire in 24 hours, and cannot
                                                                                                                                                      	// be shared with other accounts.
                                                                                                                                                      	NextToken *string
                                                                                                                                                      
                                                                                                                                                      	// An array of SearchSchemaSummary information.
                                                                                                                                                      	Schemas []types.SearchSchemaSummary
                                                                                                                                                      
                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                      }

                                                                                                                                                      type SearchSchemasPaginator

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

                                                                                                                                                        SearchSchemasPaginator is a paginator for SearchSchemas

                                                                                                                                                        func NewSearchSchemasPaginator

                                                                                                                                                        func NewSearchSchemasPaginator(client SearchSchemasAPIClient, params *SearchSchemasInput, optFns ...func(*SearchSchemasPaginatorOptions)) *SearchSchemasPaginator

                                                                                                                                                          NewSearchSchemasPaginator returns a new SearchSchemasPaginator

                                                                                                                                                          func (*SearchSchemasPaginator) HasMorePages

                                                                                                                                                          func (p *SearchSchemasPaginator) HasMorePages() bool

                                                                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                                            func (*SearchSchemasPaginator) NextPage

                                                                                                                                                            func (p *SearchSchemasPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*SearchSchemasOutput, error)

                                                                                                                                                              NextPage retrieves the next SearchSchemas page.

                                                                                                                                                              type SearchSchemasPaginatorOptions

                                                                                                                                                              type SearchSchemasPaginatorOptions struct {
                                                                                                                                                              	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
                                                                                                                                                              }

                                                                                                                                                                SearchSchemasPaginatorOptions is the paginator options for SearchSchemas

                                                                                                                                                                type StartDiscovererInput

                                                                                                                                                                type StartDiscovererInput struct {
                                                                                                                                                                
                                                                                                                                                                	// The ID of the discoverer.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	DiscovererId *string
                                                                                                                                                                }

                                                                                                                                                                type StartDiscovererOutput

                                                                                                                                                                type StartDiscovererOutput struct {
                                                                                                                                                                
                                                                                                                                                                	// The ID of the discoverer.
                                                                                                                                                                	DiscovererId *string
                                                                                                                                                                
                                                                                                                                                                	// The state of the discoverer.
                                                                                                                                                                	State types.DiscovererState
                                                                                                                                                                
                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                }

                                                                                                                                                                type StopDiscovererInput

                                                                                                                                                                type StopDiscovererInput struct {
                                                                                                                                                                
                                                                                                                                                                	// The ID of the discoverer.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	DiscovererId *string
                                                                                                                                                                }

                                                                                                                                                                type StopDiscovererOutput

                                                                                                                                                                type StopDiscovererOutput struct {
                                                                                                                                                                
                                                                                                                                                                	// The ID of the discoverer.
                                                                                                                                                                	DiscovererId *string
                                                                                                                                                                
                                                                                                                                                                	// The state of the discoverer.
                                                                                                                                                                	State types.DiscovererState
                                                                                                                                                                
                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                }

                                                                                                                                                                type TagResourceInput

                                                                                                                                                                type TagResourceInput struct {
                                                                                                                                                                
                                                                                                                                                                	// The ARN of the resource.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	ResourceArn *string
                                                                                                                                                                
                                                                                                                                                                	// Tags associated with the resource.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	Tags map[string]string
                                                                                                                                                                }

                                                                                                                                                                type TagResourceOutput

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

                                                                                                                                                                type UntagResourceInput

                                                                                                                                                                type UntagResourceInput struct {
                                                                                                                                                                
                                                                                                                                                                	// The ARN of the resource.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	ResourceArn *string
                                                                                                                                                                
                                                                                                                                                                	// Keys of key-value pairs.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	TagKeys []string
                                                                                                                                                                }

                                                                                                                                                                type UntagResourceOutput

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

                                                                                                                                                                type UpdateDiscovererInput

                                                                                                                                                                type UpdateDiscovererInput struct {
                                                                                                                                                                
                                                                                                                                                                	// The ID of the discoverer.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	DiscovererId *string
                                                                                                                                                                
                                                                                                                                                                	// The description of the discoverer to update.
                                                                                                                                                                	Description *string
                                                                                                                                                                }

                                                                                                                                                                type UpdateDiscovererOutput

                                                                                                                                                                type UpdateDiscovererOutput struct {
                                                                                                                                                                
                                                                                                                                                                	// The description of the discoverer.
                                                                                                                                                                	Description *string
                                                                                                                                                                
                                                                                                                                                                	// The ARN of the discoverer.
                                                                                                                                                                	DiscovererArn *string
                                                                                                                                                                
                                                                                                                                                                	// The ID of the discoverer.
                                                                                                                                                                	DiscovererId *string
                                                                                                                                                                
                                                                                                                                                                	// The ARN of the event bus.
                                                                                                                                                                	SourceArn *string
                                                                                                                                                                
                                                                                                                                                                	// The state of the discoverer.
                                                                                                                                                                	State types.DiscovererState
                                                                                                                                                                
                                                                                                                                                                	// Tags associated with the resource.
                                                                                                                                                                	Tags map[string]string
                                                                                                                                                                
                                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                                }

                                                                                                                                                                type UpdateRegistryInput

                                                                                                                                                                type UpdateRegistryInput struct {
                                                                                                                                                                
                                                                                                                                                                	// The name of the registry.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	RegistryName *string
                                                                                                                                                                
                                                                                                                                                                	// The description of the registry to update.
                                                                                                                                                                	Description *string
                                                                                                                                                                }

                                                                                                                                                                  Updates the registry.

                                                                                                                                                                  type UpdateRegistryOutput

                                                                                                                                                                  type UpdateRegistryOutput struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The description of the registry.
                                                                                                                                                                  	Description *string
                                                                                                                                                                  
                                                                                                                                                                  	// The ARN of the registry.
                                                                                                                                                                  	RegistryArn *string
                                                                                                                                                                  
                                                                                                                                                                  	// The name of the registry.
                                                                                                                                                                  	RegistryName *string
                                                                                                                                                                  
                                                                                                                                                                  	// Tags associated with the registry.
                                                                                                                                                                  	Tags map[string]string
                                                                                                                                                                  
                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                  }

                                                                                                                                                                  type UpdateSchemaInput

                                                                                                                                                                  type UpdateSchemaInput struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The name of the registry.
                                                                                                                                                                  	//
                                                                                                                                                                  	// This member is required.
                                                                                                                                                                  	RegistryName *string
                                                                                                                                                                  
                                                                                                                                                                  	// The name of the schema.
                                                                                                                                                                  	//
                                                                                                                                                                  	// This member is required.
                                                                                                                                                                  	SchemaName *string
                                                                                                                                                                  
                                                                                                                                                                  	// The ID of the client token.
                                                                                                                                                                  	ClientTokenId *string
                                                                                                                                                                  
                                                                                                                                                                  	// The source of the schema definition.
                                                                                                                                                                  	Content *string
                                                                                                                                                                  
                                                                                                                                                                  	// The description of the schema.
                                                                                                                                                                  	Description *string
                                                                                                                                                                  
                                                                                                                                                                  	// The schema type for the events schema.
                                                                                                                                                                  	Type types.Type
                                                                                                                                                                  }

                                                                                                                                                                  type UpdateSchemaOutput

                                                                                                                                                                  type UpdateSchemaOutput struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The description of the schema.
                                                                                                                                                                  	Description *string
                                                                                                                                                                  
                                                                                                                                                                  	// The date and time that schema was modified.
                                                                                                                                                                  	LastModified *time.Time
                                                                                                                                                                  
                                                                                                                                                                  	// The ARN of the schema.
                                                                                                                                                                  	SchemaArn *string
                                                                                                                                                                  
                                                                                                                                                                  	// The name of the schema.
                                                                                                                                                                  	SchemaName *string
                                                                                                                                                                  
                                                                                                                                                                  	// The version number of the schema
                                                                                                                                                                  	SchemaVersion *string
                                                                                                                                                                  
                                                                                                                                                                  	// Key-value pairs associated with a resource.
                                                                                                                                                                  	Tags map[string]string
                                                                                                                                                                  
                                                                                                                                                                  	// The type of the schema.
                                                                                                                                                                  	Type *string
                                                                                                                                                                  
                                                                                                                                                                  	// The date the schema version was created.
                                                                                                                                                                  	VersionCreatedDate *time.Time
                                                                                                                                                                  
                                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                                  }

                                                                                                                                                                  Directories

                                                                                                                                                                  Path Synopsis
                                                                                                                                                                  internal