Documentation

Overview

    Package mediaconnect provides the API client, operations, and parameter types for AWS MediaConnect.

    API for AWS Elemental MediaConnect

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2018-11-14"
    View Source
    const ServiceID = "MediaConnect"

    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 AddFlowOutputsInput

          type AddFlowOutputsInput struct {
          
          	// The flow that you want to add outputs to.
          	//
          	// This member is required.
          	FlowArn *string
          
          	// A list of outputs that you want to add.
          	//
          	// This member is required.
          	Outputs []types.AddOutputRequest
          }

            A request to add outputs to the specified flow.

            type AddFlowOutputsOutput

            type AddFlowOutputsOutput struct {
            
            	// The ARN of the flow that these outputs were added to.
            	FlowArn *string
            
            	// The details of the newly added outputs.
            	Outputs []types.Output
            
            	// Metadata pertaining to the operation's result.
            	ResultMetadata middleware.Metadata
            }

            type AddFlowSourcesInput

            type AddFlowSourcesInput struct {
            
            	// The flow that you want to mutate.
            	//
            	// This member is required.
            	FlowArn *string
            
            	// A list of sources that you want to add.
            	//
            	// This member is required.
            	Sources []types.SetSourceRequest
            }

              A request to add sources to the flow.

              type AddFlowSourcesOutput

              type AddFlowSourcesOutput struct {
              
              	// The ARN of the flow that these sources were added to.
              	FlowArn *string
              
              	// The details of the newly added sources.
              	Sources []types.Source
              
              	// Metadata pertaining to the operation's result.
              	ResultMetadata middleware.Metadata
              }

              type AddFlowVpcInterfacesInput

              type AddFlowVpcInterfacesInput struct {
              
              	// The flow that you want to mutate.
              	//
              	// This member is required.
              	FlowArn *string
              
              	// A list of VPC interfaces that you want to add.
              	//
              	// This member is required.
              	VpcInterfaces []types.VpcInterfaceRequest
              }

                A request to add VPC interfaces to the flow.

                type AddFlowVpcInterfacesOutput

                type AddFlowVpcInterfacesOutput struct {
                
                	// The ARN of the flow that these VPC interfaces were added to.
                	FlowArn *string
                
                	// The details of the newly added VPC interfaces.
                	VpcInterfaces []types.VpcInterface
                
                	// Metadata pertaining to the operation's result.
                	ResultMetadata middleware.Metadata
                }

                type Client

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

                  Client provides the API client to make operations call for AWS MediaConnect.

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

                      func (c *Client) AddFlowOutputs(ctx context.Context, params *AddFlowOutputsInput, optFns ...func(*Options)) (*AddFlowOutputsOutput, error)

                        Adds outputs to an existing flow. You can create up to 50 outputs per flow.

                        func (*Client) AddFlowSources

                        func (c *Client) AddFlowSources(ctx context.Context, params *AddFlowSourcesInput, optFns ...func(*Options)) (*AddFlowSourcesOutput, error)

                          Adds Sources to flow

                          func (*Client) AddFlowVpcInterfaces

                          func (c *Client) AddFlowVpcInterfaces(ctx context.Context, params *AddFlowVpcInterfacesInput, optFns ...func(*Options)) (*AddFlowVpcInterfacesOutput, error)

                            Adds VPC interfaces to flow

                            func (*Client) CreateFlow

                            func (c *Client) CreateFlow(ctx context.Context, params *CreateFlowInput, optFns ...func(*Options)) (*CreateFlowOutput, error)

                              Creates a new flow. The request must include one source. The request optionally can include outputs (up to 50) and entitlements (up to 50).

                              func (*Client) DeleteFlow

                              func (c *Client) DeleteFlow(ctx context.Context, params *DeleteFlowInput, optFns ...func(*Options)) (*DeleteFlowOutput, error)

                                Deletes a flow. Before you can delete a flow, you must stop the flow.

                                func (*Client) DescribeFlow

                                func (c *Client) DescribeFlow(ctx context.Context, params *DescribeFlowInput, optFns ...func(*Options)) (*DescribeFlowOutput, error)

                                  Displays the details of a flow. The response includes the flow ARN, name, and Availability Zone, as well as details about the source, outputs, and entitlements.

                                  func (*Client) DescribeOffering

                                  func (c *Client) DescribeOffering(ctx context.Context, params *DescribeOfferingInput, optFns ...func(*Options)) (*DescribeOfferingOutput, error)

                                    Displays the details of an offering. The response includes the offering description, duration, outbound bandwidth, price, and Amazon Resource Name (ARN).

                                    func (*Client) DescribeReservation

                                    func (c *Client) DescribeReservation(ctx context.Context, params *DescribeReservationInput, optFns ...func(*Options)) (*DescribeReservationOutput, error)

                                      Displays the details of a reservation. The response includes the reservation name, state, start date and time, and the details of the offering that make up the rest of the reservation (such as price, duration, and outbound bandwidth).

                                      func (*Client) GrantFlowEntitlements

                                      func (c *Client) GrantFlowEntitlements(ctx context.Context, params *GrantFlowEntitlementsInput, optFns ...func(*Options)) (*GrantFlowEntitlementsOutput, error)

                                        Grants entitlements to an existing flow.

                                        func (*Client) ListEntitlements

                                        func (c *Client) ListEntitlements(ctx context.Context, params *ListEntitlementsInput, optFns ...func(*Options)) (*ListEntitlementsOutput, error)

                                          Displays a list of all entitlements that have been granted to this account. This request returns 20 results per page.

                                          func (*Client) ListFlows

                                          func (c *Client) ListFlows(ctx context.Context, params *ListFlowsInput, optFns ...func(*Options)) (*ListFlowsOutput, error)

                                            Displays a list of flows that are associated with this account. This request returns a paginated result.

                                            func (*Client) ListOfferings

                                            func (c *Client) ListOfferings(ctx context.Context, params *ListOfferingsInput, optFns ...func(*Options)) (*ListOfferingsOutput, error)

                                              Displays a list of all offerings that are available to this account in the current AWS Region. If you have an active reservation (which means you've purchased an offering that has already started and hasn't expired yet), your account isn't eligible for other offerings.

                                              func (*Client) ListReservations

                                              func (c *Client) ListReservations(ctx context.Context, params *ListReservationsInput, optFns ...func(*Options)) (*ListReservationsOutput, error)

                                                Displays a list of all reservations that have been purchased by this account in the current AWS Region. This list includes all reservations in all states (such as active and expired).

                                                func (*Client) ListTagsForResource

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

                                                  List all tags on an AWS Elemental MediaConnect resource

                                                  func (*Client) PurchaseOffering

                                                  func (c *Client) PurchaseOffering(ctx context.Context, params *PurchaseOfferingInput, optFns ...func(*Options)) (*PurchaseOfferingOutput, error)

                                                    Submits a request to purchase an offering. If you already have an active reservation, you can't purchase another offering.

                                                    func (*Client) RemoveFlowOutput

                                                    func (c *Client) RemoveFlowOutput(ctx context.Context, params *RemoveFlowOutputInput, optFns ...func(*Options)) (*RemoveFlowOutputOutput, error)

                                                      Removes an output from an existing flow. This request can be made only on an output that does not have an entitlement associated with it. If the output has an entitlement, you must revoke the entitlement instead. When an entitlement is revoked from a flow, the service automatically removes the associated output.

                                                      func (*Client) RemoveFlowSource

                                                      func (c *Client) RemoveFlowSource(ctx context.Context, params *RemoveFlowSourceInput, optFns ...func(*Options)) (*RemoveFlowSourceOutput, error)

                                                        Removes a source from an existing flow. This request can be made only if there is more than one source on the flow.

                                                        func (*Client) RemoveFlowVpcInterface

                                                        func (c *Client) RemoveFlowVpcInterface(ctx context.Context, params *RemoveFlowVpcInterfaceInput, optFns ...func(*Options)) (*RemoveFlowVpcInterfaceOutput, error)

                                                          Removes a VPC Interface from an existing flow. This request can be made only on a VPC interface that does not have a Source or Output associated with it. If the VPC interface is referenced by a Source or Output, you must first delete or update the Source or Output to no longer reference the VPC interface.

                                                          func (*Client) RevokeFlowEntitlement

                                                          func (c *Client) RevokeFlowEntitlement(ctx context.Context, params *RevokeFlowEntitlementInput, optFns ...func(*Options)) (*RevokeFlowEntitlementOutput, error)

                                                            Revokes an entitlement from a flow. Once an entitlement is revoked, the content becomes unavailable to the subscriber and the associated output is removed.

                                                            func (*Client) StartFlow

                                                            func (c *Client) StartFlow(ctx context.Context, params *StartFlowInput, optFns ...func(*Options)) (*StartFlowOutput, error)

                                                              Starts a flow.

                                                              func (*Client) StopFlow

                                                              func (c *Client) StopFlow(ctx context.Context, params *StopFlowInput, optFns ...func(*Options)) (*StopFlowOutput, error)

                                                                Stops a flow.

                                                                func (*Client) TagResource

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

                                                                  Associates the specified tags to a resource with the specified resourceArn. If existing tags on a resource are not specified in the request parameters, they are not changed. When a resource is deleted, the tags associated with that resource are deleted as well.

                                                                  func (*Client) UntagResource

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

                                                                    Deletes specified tags from a resource.

                                                                    func (*Client) UpdateFlow

                                                                    func (c *Client) UpdateFlow(ctx context.Context, params *UpdateFlowInput, optFns ...func(*Options)) (*UpdateFlowOutput, error)

                                                                      Updates flow

                                                                      func (*Client) UpdateFlowEntitlement

                                                                      func (c *Client) UpdateFlowEntitlement(ctx context.Context, params *UpdateFlowEntitlementInput, optFns ...func(*Options)) (*UpdateFlowEntitlementOutput, error)

                                                                        You can change an entitlement's description, subscribers, and encryption. If you change the subscribers, the service will remove the outputs that are are used by the subscribers that are removed.

                                                                        func (*Client) UpdateFlowOutput

                                                                        func (c *Client) UpdateFlowOutput(ctx context.Context, params *UpdateFlowOutputInput, optFns ...func(*Options)) (*UpdateFlowOutputOutput, error)

                                                                          Updates an existing flow output.

                                                                          func (*Client) UpdateFlowSource

                                                                          func (c *Client) UpdateFlowSource(ctx context.Context, params *UpdateFlowSourceInput, optFns ...func(*Options)) (*UpdateFlowSourceOutput, error)

                                                                            Updates the source of a flow.

                                                                            type CreateFlowInput

                                                                            type CreateFlowInput struct {
                                                                            
                                                                            	// The name of the flow.
                                                                            	//
                                                                            	// This member is required.
                                                                            	Name *string
                                                                            
                                                                            	// The Availability Zone that you want to create the flow in. These options are
                                                                            	// limited to the Availability Zones within the current AWS Region.
                                                                            	AvailabilityZone *string
                                                                            
                                                                            	// The entitlements that you want to grant on a flow.
                                                                            	Entitlements []types.GrantEntitlementRequest
                                                                            
                                                                            	// The outputs that you want to add to this flow.
                                                                            	Outputs []types.AddOutputRequest
                                                                            
                                                                            	// The settings for the source of the flow.
                                                                            	Source *types.SetSourceRequest
                                                                            
                                                                            	// The settings for source failover
                                                                            	SourceFailoverConfig *types.FailoverConfig
                                                                            
                                                                            	Sources []types.SetSourceRequest
                                                                            
                                                                            	// The VPC interfaces you want on the flow.
                                                                            	VpcInterfaces []types.VpcInterfaceRequest
                                                                            }

                                                                              Creates a new flow. The request must include one source. The request optionally can include outputs (up to 50) and entitlements (up to 50).

                                                                              type CreateFlowOutput

                                                                              type CreateFlowOutput struct {
                                                                              
                                                                              	// The settings for a flow, including its source, outputs, and entitlements.
                                                                              	Flow *types.Flow
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type DeleteFlowInput

                                                                              type DeleteFlowInput struct {
                                                                              
                                                                              	// The ARN of the flow that you want to delete.
                                                                              	//
                                                                              	// This member is required.
                                                                              	FlowArn *string
                                                                              }

                                                                              type DeleteFlowOutput

                                                                              type DeleteFlowOutput struct {
                                                                              
                                                                              	// The ARN of the flow that was deleted.
                                                                              	FlowArn *string
                                                                              
                                                                              	// The status of the flow when the DeleteFlow process begins.
                                                                              	Status types.Status
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type DescribeFlowInput

                                                                              type DescribeFlowInput struct {
                                                                              
                                                                              	// The ARN of the flow that you want to describe.
                                                                              	//
                                                                              	// This member is required.
                                                                              	FlowArn *string
                                                                              }

                                                                              type DescribeFlowOutput

                                                                              type DescribeFlowOutput struct {
                                                                              
                                                                              	// The settings for a flow, including its source, outputs, and entitlements.
                                                                              	Flow *types.Flow
                                                                              
                                                                              	// Messages that provide the state of the flow.
                                                                              	Messages *types.Messages
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type DescribeOfferingInput

                                                                              type DescribeOfferingInput struct {
                                                                              
                                                                              	// The Amazon Resource Name (ARN) of the offering.
                                                                              	//
                                                                              	// This member is required.
                                                                              	OfferingArn *string
                                                                              }

                                                                              type DescribeOfferingOutput

                                                                              type DescribeOfferingOutput struct {
                                                                              
                                                                              	// A savings plan that reserves a certain amount of outbound bandwidth usage at a
                                                                              	// discounted rate each month over a period of time.
                                                                              	Offering *types.Offering
                                                                              
                                                                              	// Metadata pertaining to the operation's result.
                                                                              	ResultMetadata middleware.Metadata
                                                                              }

                                                                              type DescribeReservationInput

                                                                              type DescribeReservationInput struct {
                                                                              
                                                                              	// The Amazon Resource Name (ARN) of the reservation.
                                                                              	//
                                                                              	// This member is required.
                                                                              	ReservationArn *string
                                                                              }

                                                                              type DescribeReservationOutput

                                                                              type DescribeReservationOutput struct {
                                                                              
                                                                              	// A pricing agreement for a discounted rate for a specific outbound bandwidth that
                                                                              	// your MediaConnect account will use each month over a specific time period. The
                                                                              	// discounted rate in the reservation applies to outbound bandwidth for all flows
                                                                              	// from your account until your account reaches the amount of bandwidth in your
                                                                              	// reservation. If you use more outbound bandwidth than the agreed upon amount in a
                                                                              	// single month, the overage is charged at the on-demand rate.
                                                                              	Reservation *types.Reservation
                                                                              
                                                                              	// 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 GrantFlowEntitlementsInput

                                                                                      type GrantFlowEntitlementsInput struct {
                                                                                      
                                                                                      	// The list of entitlements that you want to grant.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	Entitlements []types.GrantEntitlementRequest
                                                                                      
                                                                                      	// The flow that you want to grant entitlements on.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	FlowArn *string
                                                                                      }

                                                                                        A request to grant entitlements on a flow.

                                                                                        type GrantFlowEntitlementsOutput

                                                                                        type GrantFlowEntitlementsOutput struct {
                                                                                        
                                                                                        	// The entitlements that were just granted.
                                                                                        	Entitlements []types.Entitlement
                                                                                        
                                                                                        	// The ARN of the flow that these entitlements were granted to.
                                                                                        	FlowArn *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 ListEntitlementsAPIClient

                                                                                        type ListEntitlementsAPIClient interface {
                                                                                        	ListEntitlements(context.Context, *ListEntitlementsInput, ...func(*Options)) (*ListEntitlementsOutput, error)
                                                                                        }

                                                                                          ListEntitlementsAPIClient is a client that implements the ListEntitlements operation.

                                                                                          type ListEntitlementsInput

                                                                                          type ListEntitlementsInput struct {
                                                                                          
                                                                                          	// The maximum number of results to return per API request. For example, you submit
                                                                                          	// a ListEntitlements request with MaxResults set at 5. Although 20 items match
                                                                                          	// your request, the service returns no more than the first 5 items. (The service
                                                                                          	// also returns a NextToken value that you can use to fetch the next batch of
                                                                                          	// results.) The service might return fewer results than the MaxResults value. If
                                                                                          	// MaxResults is not included in the request, the service defaults to pagination
                                                                                          	// with a maximum of 20 results per page.
                                                                                          	MaxResults int32
                                                                                          
                                                                                          	// The token that identifies which batch of results that you want to see. For
                                                                                          	// example, you submit a ListEntitlements request with MaxResults set at 5. The
                                                                                          	// service returns the first batch of results (up to 5) and a NextToken value. To
                                                                                          	// see the next batch of results, you can submit the ListEntitlements request a
                                                                                          	// second time and specify the NextToken value.
                                                                                          	NextToken *string
                                                                                          }

                                                                                          type ListEntitlementsOutput

                                                                                          type ListEntitlementsOutput struct {
                                                                                          
                                                                                          	// A list of entitlements that have been granted to you from other AWS accounts.
                                                                                          	Entitlements []types.ListedEntitlement
                                                                                          
                                                                                          	// The token that identifies which batch of results that you want to see. For
                                                                                          	// example, you submit a ListEntitlements request with MaxResults set at 5. The
                                                                                          	// service returns the first batch of results (up to 5) and a NextToken value. To
                                                                                          	// see the next batch of results, you can submit the ListEntitlements request a
                                                                                          	// second time and specify the NextToken value.
                                                                                          	NextToken *string
                                                                                          
                                                                                          	// Metadata pertaining to the operation's result.
                                                                                          	ResultMetadata middleware.Metadata
                                                                                          }

                                                                                          type ListEntitlementsPaginator

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

                                                                                            ListEntitlementsPaginator is a paginator for ListEntitlements

                                                                                            func NewListEntitlementsPaginator

                                                                                            func NewListEntitlementsPaginator(client ListEntitlementsAPIClient, params *ListEntitlementsInput, optFns ...func(*ListEntitlementsPaginatorOptions)) *ListEntitlementsPaginator

                                                                                              NewListEntitlementsPaginator returns a new ListEntitlementsPaginator

                                                                                              func (*ListEntitlementsPaginator) HasMorePages

                                                                                              func (p *ListEntitlementsPaginator) HasMorePages() bool

                                                                                                HasMorePages returns a boolean indicating whether more pages are available

                                                                                                func (*ListEntitlementsPaginator) NextPage

                                                                                                func (p *ListEntitlementsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListEntitlementsOutput, error)

                                                                                                  NextPage retrieves the next ListEntitlements page.

                                                                                                  type ListEntitlementsPaginatorOptions

                                                                                                  type ListEntitlementsPaginatorOptions struct {
                                                                                                  	// The maximum number of results to return per API request. For example, you submit
                                                                                                  	// a ListEntitlements request with MaxResults set at 5. Although 20 items match
                                                                                                  	// your request, the service returns no more than the first 5 items. (The service
                                                                                                  	// also returns a NextToken value that you can use to fetch the next batch of
                                                                                                  	// results.) The service might return fewer results than the MaxResults value. If
                                                                                                  	// MaxResults is not included in the request, the service defaults to pagination
                                                                                                  	// with a maximum of 20 results per page.
                                                                                                  	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
                                                                                                  }

                                                                                                    ListEntitlementsPaginatorOptions is the paginator options for ListEntitlements

                                                                                                    type ListFlowsAPIClient

                                                                                                    type ListFlowsAPIClient interface {
                                                                                                    	ListFlows(context.Context, *ListFlowsInput, ...func(*Options)) (*ListFlowsOutput, error)
                                                                                                    }

                                                                                                      ListFlowsAPIClient is a client that implements the ListFlows operation.

                                                                                                      type ListFlowsInput

                                                                                                      type ListFlowsInput struct {
                                                                                                      
                                                                                                      	// The maximum number of results to return per API request. For example, you submit
                                                                                                      	// a ListFlows request with MaxResults set at 5. Although 20 items match your
                                                                                                      	// request, the service returns no more than the first 5 items. (The service also
                                                                                                      	// returns a NextToken value that you can use to fetch the next batch of results.)
                                                                                                      	// The service might return fewer results than the MaxResults value. If MaxResults
                                                                                                      	// is not included in the request, the service defaults to pagination with a
                                                                                                      	// maximum of 10 results per page.
                                                                                                      	MaxResults int32
                                                                                                      
                                                                                                      	// The token that identifies which batch of results that you want to see. For
                                                                                                      	// example, you submit a ListFlows request with MaxResults set at 5. The service
                                                                                                      	// returns the first batch of results (up to 5) and a NextToken value. To see the
                                                                                                      	// next batch of results, you can submit the ListFlows request a second time and
                                                                                                      	// specify the NextToken value.
                                                                                                      	NextToken *string
                                                                                                      }

                                                                                                      type ListFlowsOutput

                                                                                                      type ListFlowsOutput struct {
                                                                                                      
                                                                                                      	// A list of flow summaries.
                                                                                                      	Flows []types.ListedFlow
                                                                                                      
                                                                                                      	// The token that identifies which batch of results that you want to see. For
                                                                                                      	// example, you submit a ListFlows request with MaxResults set at 5. The service
                                                                                                      	// returns the first batch of results (up to 5) and a NextToken value. To see the
                                                                                                      	// next batch of results, you can submit the ListFlows request a second time and
                                                                                                      	// specify the NextToken value.
                                                                                                      	NextToken *string
                                                                                                      
                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                      }

                                                                                                      type ListFlowsPaginator

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

                                                                                                        ListFlowsPaginator is a paginator for ListFlows

                                                                                                        func NewListFlowsPaginator

                                                                                                        func NewListFlowsPaginator(client ListFlowsAPIClient, params *ListFlowsInput, optFns ...func(*ListFlowsPaginatorOptions)) *ListFlowsPaginator

                                                                                                          NewListFlowsPaginator returns a new ListFlowsPaginator

                                                                                                          func (*ListFlowsPaginator) HasMorePages

                                                                                                          func (p *ListFlowsPaginator) HasMorePages() bool

                                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                                            func (*ListFlowsPaginator) NextPage

                                                                                                            func (p *ListFlowsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListFlowsOutput, error)

                                                                                                              NextPage retrieves the next ListFlows page.

                                                                                                              type ListFlowsPaginatorOptions

                                                                                                              type ListFlowsPaginatorOptions struct {
                                                                                                              	// The maximum number of results to return per API request. For example, you submit
                                                                                                              	// a ListFlows request with MaxResults set at 5. Although 20 items match your
                                                                                                              	// request, the service returns no more than the first 5 items. (The service also
                                                                                                              	// returns a NextToken value that you can use to fetch the next batch of results.)
                                                                                                              	// The service might return fewer results than the MaxResults value. If MaxResults
                                                                                                              	// is not included in the request, the service defaults to pagination with a
                                                                                                              	// maximum of 10 results per page.
                                                                                                              	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
                                                                                                              }

                                                                                                                ListFlowsPaginatorOptions is the paginator options for ListFlows

                                                                                                                type ListOfferingsAPIClient

                                                                                                                type ListOfferingsAPIClient interface {
                                                                                                                	ListOfferings(context.Context, *ListOfferingsInput, ...func(*Options)) (*ListOfferingsOutput, error)
                                                                                                                }

                                                                                                                  ListOfferingsAPIClient is a client that implements the ListOfferings operation.

                                                                                                                  type ListOfferingsInput

                                                                                                                  type ListOfferingsInput struct {
                                                                                                                  
                                                                                                                  	// The maximum number of results to return per API request. For example, you submit
                                                                                                                  	// a ListOfferings request with MaxResults set at 5. Although 20 items match your
                                                                                                                  	// request, the service returns no more than the first 5 items. (The service also
                                                                                                                  	// returns a NextToken value that you can use to fetch the next batch of results.)
                                                                                                                  	// The service might return fewer results than the MaxResults value. If MaxResults
                                                                                                                  	// is not included in the request, the service defaults to pagination with a
                                                                                                                  	// maximum of 10 results per page.
                                                                                                                  	MaxResults int32
                                                                                                                  
                                                                                                                  	// The token that identifies which batch of results that you want to see. For
                                                                                                                  	// example, you submit a ListOfferings request with MaxResults set at 5. The
                                                                                                                  	// service returns the first batch of results (up to 5) and a NextToken value. To
                                                                                                                  	// see the next batch of results, you can submit the ListOfferings request a second
                                                                                                                  	// time and specify the NextToken value.
                                                                                                                  	NextToken *string
                                                                                                                  }

                                                                                                                  type ListOfferingsOutput

                                                                                                                  type ListOfferingsOutput struct {
                                                                                                                  
                                                                                                                  	// The token that identifies which batch of results that you want to see. For
                                                                                                                  	// example, you submit a ListOfferings request with MaxResults set at 5. The
                                                                                                                  	// service returns the first batch of results (up to 5) and a NextToken value. To
                                                                                                                  	// see the next batch of results, you can submit the ListOfferings request a second
                                                                                                                  	// time and specify the NextToken value.
                                                                                                                  	NextToken *string
                                                                                                                  
                                                                                                                  	// A list of offerings that are available to this account in the current AWS
                                                                                                                  	// Region.
                                                                                                                  	Offerings []types.Offering
                                                                                                                  
                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                  }

                                                                                                                  type ListOfferingsPaginator

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

                                                                                                                    ListOfferingsPaginator is a paginator for ListOfferings

                                                                                                                    func NewListOfferingsPaginator

                                                                                                                    func NewListOfferingsPaginator(client ListOfferingsAPIClient, params *ListOfferingsInput, optFns ...func(*ListOfferingsPaginatorOptions)) *ListOfferingsPaginator

                                                                                                                      NewListOfferingsPaginator returns a new ListOfferingsPaginator

                                                                                                                      func (*ListOfferingsPaginator) HasMorePages

                                                                                                                      func (p *ListOfferingsPaginator) HasMorePages() bool

                                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                        func (*ListOfferingsPaginator) NextPage

                                                                                                                        func (p *ListOfferingsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListOfferingsOutput, error)

                                                                                                                          NextPage retrieves the next ListOfferings page.

                                                                                                                          type ListOfferingsPaginatorOptions

                                                                                                                          type ListOfferingsPaginatorOptions struct {
                                                                                                                          	// The maximum number of results to return per API request. For example, you submit
                                                                                                                          	// a ListOfferings request with MaxResults set at 5. Although 20 items match your
                                                                                                                          	// request, the service returns no more than the first 5 items. (The service also
                                                                                                                          	// returns a NextToken value that you can use to fetch the next batch of results.)
                                                                                                                          	// The service might return fewer results than the MaxResults value. If MaxResults
                                                                                                                          	// is not included in the request, the service defaults to pagination with a
                                                                                                                          	// maximum of 10 results per page.
                                                                                                                          	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
                                                                                                                          }

                                                                                                                            ListOfferingsPaginatorOptions is the paginator options for ListOfferings

                                                                                                                            type ListReservationsAPIClient

                                                                                                                            type ListReservationsAPIClient interface {
                                                                                                                            	ListReservations(context.Context, *ListReservationsInput, ...func(*Options)) (*ListReservationsOutput, error)
                                                                                                                            }

                                                                                                                              ListReservationsAPIClient is a client that implements the ListReservations operation.

                                                                                                                              type ListReservationsInput

                                                                                                                              type ListReservationsInput struct {
                                                                                                                              
                                                                                                                              	// The maximum number of results to return per API request. For example, you submit
                                                                                                                              	// a ListReservations request with MaxResults set at 5. Although 20 items match
                                                                                                                              	// your request, the service returns no more than the first 5 items. (The service
                                                                                                                              	// also returns a NextToken value that you can use to fetch the next batch of
                                                                                                                              	// results.) The service might return fewer results than the MaxResults value. If
                                                                                                                              	// MaxResults is not included in the request, the service defaults to pagination
                                                                                                                              	// with a maximum of 10 results per page.
                                                                                                                              	MaxResults int32
                                                                                                                              
                                                                                                                              	// The token that identifies which batch of results that you want to see. For
                                                                                                                              	// example, you submit a ListReservations request with MaxResults set at 5. The
                                                                                                                              	// service returns the first batch of results (up to 5) and a NextToken value. To
                                                                                                                              	// see the next batch of results, you can submit the ListOfferings request a second
                                                                                                                              	// time and specify the NextToken value.
                                                                                                                              	NextToken *string
                                                                                                                              }

                                                                                                                              type ListReservationsOutput

                                                                                                                              type ListReservationsOutput struct {
                                                                                                                              
                                                                                                                              	// The token that identifies which batch of results that you want to see. For
                                                                                                                              	// example, you submit a ListReservations request with MaxResults set at 5. The
                                                                                                                              	// service returns the first batch of results (up to 5) and a NextToken value. To
                                                                                                                              	// see the next batch of results, you can submit the ListReservations request a
                                                                                                                              	// second time and specify the NextToken value.
                                                                                                                              	NextToken *string
                                                                                                                              
                                                                                                                              	// A list of all reservations that have been purchased by this account in the
                                                                                                                              	// current AWS Region.
                                                                                                                              	Reservations []types.Reservation
                                                                                                                              
                                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                                              }

                                                                                                                              type ListReservationsPaginator

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

                                                                                                                                ListReservationsPaginator is a paginator for ListReservations

                                                                                                                                func NewListReservationsPaginator

                                                                                                                                func NewListReservationsPaginator(client ListReservationsAPIClient, params *ListReservationsInput, optFns ...func(*ListReservationsPaginatorOptions)) *ListReservationsPaginator

                                                                                                                                  NewListReservationsPaginator returns a new ListReservationsPaginator

                                                                                                                                  func (*ListReservationsPaginator) HasMorePages

                                                                                                                                  func (p *ListReservationsPaginator) HasMorePages() bool

                                                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                    func (*ListReservationsPaginator) NextPage

                                                                                                                                    func (p *ListReservationsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListReservationsOutput, error)

                                                                                                                                      NextPage retrieves the next ListReservations page.

                                                                                                                                      type ListReservationsPaginatorOptions

                                                                                                                                      type ListReservationsPaginatorOptions struct {
                                                                                                                                      	// The maximum number of results to return per API request. For example, you submit
                                                                                                                                      	// a ListReservations request with MaxResults set at 5. Although 20 items match
                                                                                                                                      	// your request, the service returns no more than the first 5 items. (The service
                                                                                                                                      	// also returns a NextToken value that you can use to fetch the next batch of
                                                                                                                                      	// results.) The service might return fewer results than the MaxResults value. If
                                                                                                                                      	// MaxResults is not included in the request, the service defaults to pagination
                                                                                                                                      	// with a maximum of 10 results per page.
                                                                                                                                      	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
                                                                                                                                      }

                                                                                                                                        ListReservationsPaginatorOptions is the paginator options for ListReservations

                                                                                                                                        type ListTagsForResourceInput

                                                                                                                                        type ListTagsForResourceInput struct {
                                                                                                                                        
                                                                                                                                        	// The Amazon Resource Name (ARN) that identifies the AWS Elemental MediaConnect
                                                                                                                                        	// resource for which to list the tags.
                                                                                                                                        	//
                                                                                                                                        	// This member is required.
                                                                                                                                        	ResourceArn *string
                                                                                                                                        }

                                                                                                                                        type ListTagsForResourceOutput

                                                                                                                                        type ListTagsForResourceOutput struct {
                                                                                                                                        
                                                                                                                                        	// A map from tag keys to values. Tag keys can have a maximum character length of
                                                                                                                                        	// 128 characters, and tag values can have a maximum length of 256 characters.
                                                                                                                                        	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
                                                                                                                                        
                                                                                                                                        	// 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 PurchaseOfferingInput

                                                                                                                                          type PurchaseOfferingInput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) of the offering.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	OfferingArn *string
                                                                                                                                          
                                                                                                                                          	// The name that you want to use for the reservation.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	ReservationName *string
                                                                                                                                          
                                                                                                                                          	// The date and time that you want the reservation to begin, in Coordinated
                                                                                                                                          	// Universal Time (UTC). You can specify any date and time between 12:00am on the
                                                                                                                                          	// first day of the current month to the current time on today's date, inclusive.
                                                                                                                                          	// Specify the start in a 24-hour notation. Use the following format:
                                                                                                                                          	// YYYY-MM-DDTHH:mm:SSZ, where T and Z are literal characters. For example, to
                                                                                                                                          	// specify 11:30pm on March 5, 2020, enter 2020-03-05T23:30:00Z.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Start *string
                                                                                                                                          }

                                                                                                                                            A request to purchase a offering.

                                                                                                                                            type PurchaseOfferingOutput

                                                                                                                                            type PurchaseOfferingOutput struct {
                                                                                                                                            
                                                                                                                                            	// A pricing agreement for a discounted rate for a specific outbound bandwidth that
                                                                                                                                            	// your MediaConnect account will use each month over a specific time period. The
                                                                                                                                            	// discounted rate in the reservation applies to outbound bandwidth for all flows
                                                                                                                                            	// from your account until your account reaches the amount of bandwidth in your
                                                                                                                                            	// reservation. If you use more outbound bandwidth than the agreed upon amount in a
                                                                                                                                            	// single month, the overage is charged at the on-demand rate.
                                                                                                                                            	Reservation *types.Reservation
                                                                                                                                            
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type RemoveFlowOutputInput

                                                                                                                                            type RemoveFlowOutputInput struct {
                                                                                                                                            
                                                                                                                                            	// The flow that you want to remove an output from.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	FlowArn *string
                                                                                                                                            
                                                                                                                                            	// The ARN of the output that you want to remove.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	OutputArn *string
                                                                                                                                            }

                                                                                                                                            type RemoveFlowOutputOutput

                                                                                                                                            type RemoveFlowOutputOutput struct {
                                                                                                                                            
                                                                                                                                            	// The ARN of the flow that is associated with the output you removed.
                                                                                                                                            	FlowArn *string
                                                                                                                                            
                                                                                                                                            	// The ARN of the output that was removed.
                                                                                                                                            	OutputArn *string
                                                                                                                                            
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type RemoveFlowSourceInput

                                                                                                                                            type RemoveFlowSourceInput struct {
                                                                                                                                            
                                                                                                                                            	// The flow that you want to remove a source from.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	FlowArn *string
                                                                                                                                            
                                                                                                                                            	// The ARN of the source that you want to remove.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	SourceArn *string
                                                                                                                                            }

                                                                                                                                            type RemoveFlowSourceOutput

                                                                                                                                            type RemoveFlowSourceOutput struct {
                                                                                                                                            
                                                                                                                                            	// The ARN of the flow that is associated with the source you removed.
                                                                                                                                            	FlowArn *string
                                                                                                                                            
                                                                                                                                            	// The ARN of the source that was removed.
                                                                                                                                            	SourceArn *string
                                                                                                                                            
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type RemoveFlowVpcInterfaceInput

                                                                                                                                            type RemoveFlowVpcInterfaceInput struct {
                                                                                                                                            
                                                                                                                                            	// The flow that you want to remove a VPC interface from.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	FlowArn *string
                                                                                                                                            
                                                                                                                                            	// The name of the VPC interface that you want to remove.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	VpcInterfaceName *string
                                                                                                                                            }

                                                                                                                                            type RemoveFlowVpcInterfaceOutput

                                                                                                                                            type RemoveFlowVpcInterfaceOutput struct {
                                                                                                                                            
                                                                                                                                            	// The ARN of the flow that is associated with the VPC interface you removed.
                                                                                                                                            	FlowArn *string
                                                                                                                                            
                                                                                                                                            	// IDs of network interfaces associated with the removed VPC interface that Media
                                                                                                                                            	// Connect was unable to remove.
                                                                                                                                            	NonDeletedNetworkInterfaceIds []string
                                                                                                                                            
                                                                                                                                            	// The name of the VPC interface that was removed.
                                                                                                                                            	VpcInterfaceName *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 RevokeFlowEntitlementInput

                                                                                                                                            type RevokeFlowEntitlementInput struct {
                                                                                                                                            
                                                                                                                                            	// The ARN of the entitlement that you want to revoke.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	EntitlementArn *string
                                                                                                                                            
                                                                                                                                            	// The flow that you want to revoke an entitlement from.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	FlowArn *string
                                                                                                                                            }

                                                                                                                                            type RevokeFlowEntitlementOutput

                                                                                                                                            type RevokeFlowEntitlementOutput struct {
                                                                                                                                            
                                                                                                                                            	// The ARN of the entitlement that was revoked.
                                                                                                                                            	EntitlementArn *string
                                                                                                                                            
                                                                                                                                            	// The ARN of the flow that the entitlement was revoked from.
                                                                                                                                            	FlowArn *string
                                                                                                                                            
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type StartFlowInput

                                                                                                                                            type StartFlowInput struct {
                                                                                                                                            
                                                                                                                                            	// The ARN of the flow that you want to start.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	FlowArn *string
                                                                                                                                            }

                                                                                                                                            type StartFlowOutput

                                                                                                                                            type StartFlowOutput struct {
                                                                                                                                            
                                                                                                                                            	// The ARN of the flow that you started.
                                                                                                                                            	FlowArn *string
                                                                                                                                            
                                                                                                                                            	// The status of the flow when the StartFlow process begins.
                                                                                                                                            	Status types.Status
                                                                                                                                            
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type StopFlowInput

                                                                                                                                            type StopFlowInput struct {
                                                                                                                                            
                                                                                                                                            	// The ARN of the flow that you want to stop.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	FlowArn *string
                                                                                                                                            }

                                                                                                                                            type StopFlowOutput

                                                                                                                                            type StopFlowOutput struct {
                                                                                                                                            
                                                                                                                                            	// The ARN of the flow that you stopped.
                                                                                                                                            	FlowArn *string
                                                                                                                                            
                                                                                                                                            	// The status of the flow when the StopFlow process begins.
                                                                                                                                            	Status types.Status
                                                                                                                                            
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type TagResourceInput

                                                                                                                                            type TagResourceInput struct {
                                                                                                                                            
                                                                                                                                            	// The Amazon Resource Name (ARN) that identifies the AWS Elemental MediaConnect
                                                                                                                                            	// resource to which to add tags.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	ResourceArn *string
                                                                                                                                            
                                                                                                                                            	// A map from tag keys to values. Tag keys can have a maximum character length of
                                                                                                                                            	// 128 characters, and tag values can have a maximum length of 256 characters.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	Tags map[string]string
                                                                                                                                            }

                                                                                                                                              The tags to add to the resource. A tag is an array of key-value pairs. Tag keys can have a maximum character length of 128 characters, and tag values can have a maximum length of 256 characters.

                                                                                                                                              type TagResourceOutput

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

                                                                                                                                              type UntagResourceInput

                                                                                                                                              type UntagResourceInput struct {
                                                                                                                                              
                                                                                                                                              	// The Amazon Resource Name (ARN) that identifies the AWS Elemental MediaConnect
                                                                                                                                              	// resource from which to delete tags.
                                                                                                                                              	//
                                                                                                                                              	// This member is required.
                                                                                                                                              	ResourceArn *string
                                                                                                                                              
                                                                                                                                              	// The keys of the tags to be removed.
                                                                                                                                              	//
                                                                                                                                              	// This member is required.
                                                                                                                                              	TagKeys []string
                                                                                                                                              }

                                                                                                                                              type UntagResourceOutput

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

                                                                                                                                              type UpdateFlowEntitlementInput

                                                                                                                                              type UpdateFlowEntitlementInput struct {
                                                                                                                                              
                                                                                                                                              	// The ARN of the entitlement that you want to update.
                                                                                                                                              	//
                                                                                                                                              	// This member is required.
                                                                                                                                              	EntitlementArn *string
                                                                                                                                              
                                                                                                                                              	// The flow that is associated with the entitlement that you want to update.
                                                                                                                                              	//
                                                                                                                                              	// This member is required.
                                                                                                                                              	FlowArn *string
                                                                                                                                              
                                                                                                                                              	// A description of the entitlement. This description appears only on the AWS
                                                                                                                                              	// Elemental MediaConnect console and will not be seen by the subscriber or end
                                                                                                                                              	// user.
                                                                                                                                              	Description *string
                                                                                                                                              
                                                                                                                                              	// The type of encryption that will be used on the output associated with this
                                                                                                                                              	// entitlement.
                                                                                                                                              	Encryption *types.UpdateEncryption
                                                                                                                                              
                                                                                                                                              	// An indication of whether you want to enable the entitlement to allow access, or
                                                                                                                                              	// disable it to stop streaming content to the subscriber’s flow temporarily. If
                                                                                                                                              	// you don’t specify the entitlementStatus field in your request, MediaConnect
                                                                                                                                              	// leaves the value unchanged.
                                                                                                                                              	EntitlementStatus types.EntitlementStatus
                                                                                                                                              
                                                                                                                                              	// The AWS account IDs that you want to share your content with. The receiving
                                                                                                                                              	// accounts (subscribers) will be allowed to create their own flow using your
                                                                                                                                              	// content as the source.
                                                                                                                                              	Subscribers []string
                                                                                                                                              }

                                                                                                                                                The entitlement fields that you want to update.

                                                                                                                                                type UpdateFlowEntitlementOutput

                                                                                                                                                type UpdateFlowEntitlementOutput struct {
                                                                                                                                                
                                                                                                                                                	// The new configuration of the entitlement that you updated.
                                                                                                                                                	Entitlement *types.Entitlement
                                                                                                                                                
                                                                                                                                                	// The ARN of the flow that this entitlement was granted on.
                                                                                                                                                	FlowArn *string
                                                                                                                                                
                                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                                }

                                                                                                                                                type UpdateFlowInput

                                                                                                                                                type UpdateFlowInput struct {
                                                                                                                                                
                                                                                                                                                	// The flow that you want to update.
                                                                                                                                                	//
                                                                                                                                                	// This member is required.
                                                                                                                                                	FlowArn *string
                                                                                                                                                
                                                                                                                                                	// The settings for source failover
                                                                                                                                                	SourceFailoverConfig *types.UpdateFailoverConfig
                                                                                                                                                }

                                                                                                                                                  A request to update flow.

                                                                                                                                                  type UpdateFlowOutput

                                                                                                                                                  type UpdateFlowOutput struct {
                                                                                                                                                  
                                                                                                                                                  	// The settings for a flow, including its source, outputs, and entitlements.
                                                                                                                                                  	Flow *types.Flow
                                                                                                                                                  
                                                                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                                                                  }

                                                                                                                                                  type UpdateFlowOutputInput

                                                                                                                                                  type UpdateFlowOutputInput struct {
                                                                                                                                                  
                                                                                                                                                  	// The flow that is associated with the output that you want to update.
                                                                                                                                                  	//
                                                                                                                                                  	// This member is required.
                                                                                                                                                  	FlowArn *string
                                                                                                                                                  
                                                                                                                                                  	// The ARN of the output that you want to update.
                                                                                                                                                  	//
                                                                                                                                                  	// This member is required.
                                                                                                                                                  	OutputArn *string
                                                                                                                                                  
                                                                                                                                                  	// The range of IP addresses that should be allowed to initiate output requests to
                                                                                                                                                  	// this flow. These IP addresses should be in the form of a Classless Inter-Domain
                                                                                                                                                  	// Routing (CIDR) block; for example, 10.0.0.0/16.
                                                                                                                                                  	CidrAllowList []string
                                                                                                                                                  
                                                                                                                                                  	// A description of the output. This description appears only on the AWS Elemental
                                                                                                                                                  	// MediaConnect console and will not be seen by the end user.
                                                                                                                                                  	Description *string
                                                                                                                                                  
                                                                                                                                                  	// The IP address where you want to send the output.
                                                                                                                                                  	Destination *string
                                                                                                                                                  
                                                                                                                                                  	// The type of key used for the encryption. If no keyType is provided, the service
                                                                                                                                                  	// will use the default setting (static-key).
                                                                                                                                                  	Encryption *types.UpdateEncryption
                                                                                                                                                  
                                                                                                                                                  	// The maximum latency in milliseconds for Zixi-based streams.
                                                                                                                                                  	MaxLatency int32
                                                                                                                                                  
                                                                                                                                                  	// The port to use when content is distributed to this output.
                                                                                                                                                  	Port int32
                                                                                                                                                  
                                                                                                                                                  	// The protocol to use for the output.
                                                                                                                                                  	Protocol types.Protocol
                                                                                                                                                  
                                                                                                                                                  	// The remote ID for the Zixi-pull stream.
                                                                                                                                                  	RemoteId *string
                                                                                                                                                  
                                                                                                                                                  	// The smoothing latency in milliseconds for RIST, RTP, and RTP-FEC streams.
                                                                                                                                                  	SmoothingLatency int32
                                                                                                                                                  
                                                                                                                                                  	// The stream ID that you want to use for this transport. This parameter applies
                                                                                                                                                  	// only to Zixi-based streams.
                                                                                                                                                  	StreamId *string
                                                                                                                                                  
                                                                                                                                                  	// The name of the VPC interface attachment to use for this output.
                                                                                                                                                  	VpcInterfaceAttachment *types.VpcInterfaceAttachment
                                                                                                                                                  }

                                                                                                                                                    The fields that you want to update in the output.

                                                                                                                                                    type UpdateFlowOutputOutput

                                                                                                                                                    type UpdateFlowOutputOutput struct {
                                                                                                                                                    
                                                                                                                                                    	// The ARN of the flow that is associated with the updated output.
                                                                                                                                                    	FlowArn *string
                                                                                                                                                    
                                                                                                                                                    	// The new settings of the output that you updated.
                                                                                                                                                    	Output *types.Output
                                                                                                                                                    
                                                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                                                    }

                                                                                                                                                    type UpdateFlowSourceInput

                                                                                                                                                    type UpdateFlowSourceInput struct {
                                                                                                                                                    
                                                                                                                                                    	// The flow that is associated with the source that you want to update.
                                                                                                                                                    	//
                                                                                                                                                    	// This member is required.
                                                                                                                                                    	FlowArn *string
                                                                                                                                                    
                                                                                                                                                    	// The ARN of the source that you want to update.
                                                                                                                                                    	//
                                                                                                                                                    	// This member is required.
                                                                                                                                                    	SourceArn *string
                                                                                                                                                    
                                                                                                                                                    	// The type of encryption used on the content ingested from this source.
                                                                                                                                                    	Decryption *types.UpdateEncryption
                                                                                                                                                    
                                                                                                                                                    	// A description for the source. This value is not used or seen outside of the
                                                                                                                                                    	// current AWS Elemental MediaConnect account.
                                                                                                                                                    	Description *string
                                                                                                                                                    
                                                                                                                                                    	// The ARN of the entitlement that allows you to subscribe to this flow. The
                                                                                                                                                    	// entitlement is set by the flow originator, and the ARN is generated as part of
                                                                                                                                                    	// the originator's flow.
                                                                                                                                                    	EntitlementArn *string
                                                                                                                                                    
                                                                                                                                                    	// The port that the flow will be listening on for incoming content.
                                                                                                                                                    	IngestPort int32
                                                                                                                                                    
                                                                                                                                                    	// The smoothing max bitrate for RIST, RTP, and RTP-FEC streams.
                                                                                                                                                    	MaxBitrate int32
                                                                                                                                                    
                                                                                                                                                    	// The maximum latency in milliseconds. This parameter applies only to RIST-based
                                                                                                                                                    	// and Zixi-based streams.
                                                                                                                                                    	MaxLatency int32
                                                                                                                                                    
                                                                                                                                                    	// The protocol that is used by the source.
                                                                                                                                                    	Protocol types.Protocol
                                                                                                                                                    
                                                                                                                                                    	// The stream ID that you want to use for this transport. This parameter applies
                                                                                                                                                    	// only to Zixi-based streams.
                                                                                                                                                    	StreamId *string
                                                                                                                                                    
                                                                                                                                                    	// The name of the VPC Interface to configure this Source with.
                                                                                                                                                    	VpcInterfaceName *string
                                                                                                                                                    
                                                                                                                                                    	// The range of IP addresses that should be allowed to contribute content to your
                                                                                                                                                    	// source. These IP addresses should be in the form of a Classless Inter-Domain
                                                                                                                                                    	// Routing (CIDR) block; for example, 10.0.0.0/16.
                                                                                                                                                    	WhitelistCidr *string
                                                                                                                                                    }

                                                                                                                                                      A request to update the source of a flow.

                                                                                                                                                      type UpdateFlowSourceOutput

                                                                                                                                                      type UpdateFlowSourceOutput struct {
                                                                                                                                                      
                                                                                                                                                      	// The ARN of the flow that you want to update.
                                                                                                                                                      	FlowArn *string
                                                                                                                                                      
                                                                                                                                                      	// The settings for the source of the flow.
                                                                                                                                                      	Source *types.Source
                                                                                                                                                      
                                                                                                                                                      	// Metadata pertaining to the operation's result.
                                                                                                                                                      	ResultMetadata middleware.Metadata
                                                                                                                                                      }

                                                                                                                                                      Directories

                                                                                                                                                      Path Synopsis
                                                                                                                                                      internal