Documentation

Overview

    Package mediaconvert provides the API client, operations, and parameter types for AWS Elemental MediaConvert.

    AWS Elemental MediaConvert

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2017-08-29"
    View Source
    const ServiceID = "MediaConvert"

    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 AssociateCertificateInput

          type AssociateCertificateInput struct {
          
          	// The ARN of the ACM certificate that you want to associate with your MediaConvert
          	// resource.
          	//
          	// This member is required.
          	Arn *string
          }

          type AssociateCertificateOutput

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

          type CancelJobInput

          type CancelJobInput struct {
          
          	// The Job ID of the job to be cancelled.
          	//
          	// This member is required.
          	Id *string
          }

          type CancelJobOutput

          type CancelJobOutput struct {
          	// 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 Elemental MediaConvert.

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

                func (c *Client) AssociateCertificate(ctx context.Context, params *AssociateCertificateInput, optFns ...func(*Options)) (*AssociateCertificateOutput, error)

                  Associates an AWS Certificate Manager (ACM) Amazon Resource Name (ARN) with AWS Elemental MediaConvert.

                  func (*Client) CancelJob

                  func (c *Client) CancelJob(ctx context.Context, params *CancelJobInput, optFns ...func(*Options)) (*CancelJobOutput, error)

                    Permanently cancel a job. Once you have canceled a job, you can't start it again.

                    func (*Client) CreateJob

                    func (c *Client) CreateJob(ctx context.Context, params *CreateJobInput, optFns ...func(*Options)) (*CreateJobOutput, error)

                      Create a new transcoding job. For information about jobs and job settings, see the User Guide at http://docs.aws.amazon.com/mediaconvert/latest/ug/what-is.html

                      func (*Client) CreateJobTemplate

                      func (c *Client) CreateJobTemplate(ctx context.Context, params *CreateJobTemplateInput, optFns ...func(*Options)) (*CreateJobTemplateOutput, error)

                        Create a new job template. For information about job templates see the User Guide at http://docs.aws.amazon.com/mediaconvert/latest/ug/what-is.html

                        func (*Client) CreatePreset

                        func (c *Client) CreatePreset(ctx context.Context, params *CreatePresetInput, optFns ...func(*Options)) (*CreatePresetOutput, error)

                          Create a new preset. For information about job templates see the User Guide at http://docs.aws.amazon.com/mediaconvert/latest/ug/what-is.html

                          func (*Client) CreateQueue

                          func (c *Client) CreateQueue(ctx context.Context, params *CreateQueueInput, optFns ...func(*Options)) (*CreateQueueOutput, error)

                            Create a new transcoding queue. For information about queues, see Working With Queues in the User Guide at https://docs.aws.amazon.com/mediaconvert/latest/ug/working-with-queues.html

                            func (*Client) DeleteJobTemplate

                            func (c *Client) DeleteJobTemplate(ctx context.Context, params *DeleteJobTemplateInput, optFns ...func(*Options)) (*DeleteJobTemplateOutput, error)

                              Permanently delete a job template you have created.

                              func (*Client) DeletePreset

                              func (c *Client) DeletePreset(ctx context.Context, params *DeletePresetInput, optFns ...func(*Options)) (*DeletePresetOutput, error)

                                Permanently delete a preset you have created.

                                func (*Client) DeleteQueue

                                func (c *Client) DeleteQueue(ctx context.Context, params *DeleteQueueInput, optFns ...func(*Options)) (*DeleteQueueOutput, error)

                                  Permanently delete a queue you have created.

                                  func (*Client) DescribeEndpoints

                                  func (c *Client) DescribeEndpoints(ctx context.Context, params *DescribeEndpointsInput, optFns ...func(*Options)) (*DescribeEndpointsOutput, error)

                                    Send an request with an empty body to the regional API endpoint to get your account API endpoint.

                                    func (*Client) DisassociateCertificate

                                    func (c *Client) DisassociateCertificate(ctx context.Context, params *DisassociateCertificateInput, optFns ...func(*Options)) (*DisassociateCertificateOutput, error)

                                      Removes an association between the Amazon Resource Name (ARN) of an AWS Certificate Manager (ACM) certificate and an AWS Elemental MediaConvert resource.

                                      func (*Client) GetJob

                                      func (c *Client) GetJob(ctx context.Context, params *GetJobInput, optFns ...func(*Options)) (*GetJobOutput, error)

                                        Retrieve the JSON for a specific completed transcoding job.

                                        func (*Client) GetJobTemplate

                                        func (c *Client) GetJobTemplate(ctx context.Context, params *GetJobTemplateInput, optFns ...func(*Options)) (*GetJobTemplateOutput, error)

                                          Retrieve the JSON for a specific job template.

                                          func (*Client) GetPreset

                                          func (c *Client) GetPreset(ctx context.Context, params *GetPresetInput, optFns ...func(*Options)) (*GetPresetOutput, error)

                                            Retrieve the JSON for a specific preset.

                                            func (*Client) GetQueue

                                            func (c *Client) GetQueue(ctx context.Context, params *GetQueueInput, optFns ...func(*Options)) (*GetQueueOutput, error)

                                              Retrieve the JSON for a specific queue.

                                              func (*Client) ListJobTemplates

                                              func (c *Client) ListJobTemplates(ctx context.Context, params *ListJobTemplatesInput, optFns ...func(*Options)) (*ListJobTemplatesOutput, error)

                                                Retrieve a JSON array of up to twenty of your job templates. This will return the templates themselves, not just a list of them. To retrieve the next twenty templates, use the nextToken string returned with the array

                                                func (*Client) ListJobs

                                                func (c *Client) ListJobs(ctx context.Context, params *ListJobsInput, optFns ...func(*Options)) (*ListJobsOutput, error)

                                                  Retrieve a JSON array of up to twenty of your most recently created jobs. This array includes in-process, completed, and errored jobs. This will return the jobs themselves, not just a list of the jobs. To retrieve the twenty next most recent jobs, use the nextToken string returned with the array.

                                                  func (*Client) ListPresets

                                                  func (c *Client) ListPresets(ctx context.Context, params *ListPresetsInput, optFns ...func(*Options)) (*ListPresetsOutput, error)

                                                    Retrieve a JSON array of up to twenty of your presets. This will return the presets themselves, not just a list of them. To retrieve the next twenty presets, use the nextToken string returned with the array.

                                                    func (*Client) ListQueues

                                                    func (c *Client) ListQueues(ctx context.Context, params *ListQueuesInput, optFns ...func(*Options)) (*ListQueuesOutput, error)

                                                      Retrieve a JSON array of up to twenty of your queues. This will return the queues themselves, not just a list of them. To retrieve the next twenty queues, use the nextToken string returned with the array.

                                                      func (*Client) ListTagsForResource

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

                                                        Retrieve the tags for a MediaConvert resource.

                                                        func (*Client) TagResource

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

                                                          Add tags to a MediaConvert queue, preset, or job template. For information about tagging, see the User Guide at https://docs.aws.amazon.com/mediaconvert/latest/ug/tagging-resources.html

                                                          func (*Client) UntagResource

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

                                                            Remove tags from a MediaConvert queue, preset, or job template. For information about tagging, see the User Guide at https://docs.aws.amazon.com/mediaconvert/latest/ug/tagging-resources.html

                                                            func (*Client) UpdateJobTemplate

                                                            func (c *Client) UpdateJobTemplate(ctx context.Context, params *UpdateJobTemplateInput, optFns ...func(*Options)) (*UpdateJobTemplateOutput, error)

                                                              Modify one of your existing job templates.

                                                              func (*Client) UpdatePreset

                                                              func (c *Client) UpdatePreset(ctx context.Context, params *UpdatePresetInput, optFns ...func(*Options)) (*UpdatePresetOutput, error)

                                                                Modify one of your existing presets.

                                                                func (*Client) UpdateQueue

                                                                func (c *Client) UpdateQueue(ctx context.Context, params *UpdateQueueInput, optFns ...func(*Options)) (*UpdateQueueOutput, error)

                                                                  Modify one of your existing queues.

                                                                  type CreateJobInput

                                                                  type CreateJobInput struct {
                                                                  
                                                                  	// Required. The IAM role you use for creating this job. For details about
                                                                  	// permissions, see the User Guide topic at the User Guide at
                                                                  	// https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Role *string
                                                                  
                                                                  	// JobSettings contains all the transcode settings for a job.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Settings *types.JobSettings
                                                                  
                                                                  	// Optional. Accelerated transcoding can significantly speed up jobs with long,
                                                                  	// visually complex content. Outputs that use this feature incur pro-tier pricing.
                                                                  	// For information about feature limitations, see the AWS Elemental MediaConvert
                                                                  	// User Guide.
                                                                  	AccelerationSettings *types.AccelerationSettings
                                                                  
                                                                  	// Optional. Choose a tag type that AWS Billing and Cost Management will use to
                                                                  	// sort your AWS Elemental MediaConvert costs on any billing report that you set
                                                                  	// up. Any transcoding outputs that don't have an associated tag will appear in
                                                                  	// your billing report unsorted. If you don't choose a valid value for this field,
                                                                  	// your job outputs will appear on the billing report unsorted.
                                                                  	BillingTagsSource types.BillingTagsSource
                                                                  
                                                                  	// Optional. Idempotency token for CreateJob operation.
                                                                  	ClientRequestToken *string
                                                                  
                                                                  	// Optional. Use queue hopping to avoid overly long waits in the backlog of the
                                                                  	// queue that you submit your job to. Specify an alternate queue and the maximum
                                                                  	// time that your job will wait in the initial queue before hopping. For more
                                                                  	// information about this feature, see the AWS Elemental MediaConvert User Guide.
                                                                  	HopDestinations []types.HopDestination
                                                                  
                                                                  	// Optional. When you create a job, you can either specify a job template or
                                                                  	// specify the transcoding settings individually.
                                                                  	JobTemplate *string
                                                                  
                                                                  	// Optional. Specify the relative priority for this job. In any given queue, the
                                                                  	// service begins processing the job with the highest value first. When more than
                                                                  	// one job has the same priority, the service begins processing the job that you
                                                                  	// submitted first. If you don't specify a priority, the service uses the default
                                                                  	// value 0.
                                                                  	Priority int32
                                                                  
                                                                  	// Optional. When you create a job, you can specify a queue to send it to. If you
                                                                  	// don't specify, the job will go to the default queue. For more about queues, see
                                                                  	// the User Guide topic at
                                                                  	// https://docs.aws.amazon.com/mediaconvert/latest/ug/what-is.html.
                                                                  	Queue *string
                                                                  
                                                                  	// Optional. Enable this setting when you run a test job to estimate how many
                                                                  	// reserved transcoding slots (RTS) you need. When this is enabled, MediaConvert
                                                                  	// runs your job from an on-demand queue with similar performance to what you will
                                                                  	// see with one RTS in a reserved queue. This setting is disabled by default.
                                                                  	SimulateReservedQueue types.SimulateReservedQueue
                                                                  
                                                                  	// Optional. Specify how often MediaConvert sends STATUS_UPDATE events to Amazon
                                                                  	// CloudWatch Events. Set the interval, in seconds, between status updates.
                                                                  	// MediaConvert sends an update at this interval from the time the service begins
                                                                  	// processing your job to the time it completes the transcode or encounters an
                                                                  	// error.
                                                                  	StatusUpdateInterval types.StatusUpdateInterval
                                                                  
                                                                  	// Optional. The tags that you want to add to the resource. You can tag resources
                                                                  	// with a key-value pair or with only a key. Use standard AWS tags on your job for
                                                                  	// automatic integration with AWS services and for custom integrations and
                                                                  	// workflows.
                                                                  	Tags map[string]string
                                                                  
                                                                  	// Optional. User-defined metadata that you want to associate with an MediaConvert
                                                                  	// job. You specify metadata in key/value pairs. Use only for existing integrations
                                                                  	// or workflows that rely on job metadata tags. Otherwise, we recommend that you
                                                                  	// use standard AWS tags.
                                                                  	UserMetadata map[string]string
                                                                  }

                                                                  type CreateJobOutput

                                                                  type CreateJobOutput struct {
                                                                  
                                                                  	// Each job converts an input file into an output file or files. For more
                                                                  	// information, see the User Guide at
                                                                  	// https://docs.aws.amazon.com/mediaconvert/latest/ug/what-is.html
                                                                  	Job *types.Job
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type CreateJobTemplateInput

                                                                  type CreateJobTemplateInput struct {
                                                                  
                                                                  	// The name of the job template you are creating.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Name *string
                                                                  
                                                                  	// JobTemplateSettings contains all the transcode settings saved in the template
                                                                  	// that will be applied to jobs created from it.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Settings *types.JobTemplateSettings
                                                                  
                                                                  	// Accelerated transcoding can significantly speed up jobs with long, visually
                                                                  	// complex content. Outputs that use this feature incur pro-tier pricing. For
                                                                  	// information about feature limitations, see the AWS Elemental MediaConvert User
                                                                  	// Guide.
                                                                  	AccelerationSettings *types.AccelerationSettings
                                                                  
                                                                  	// Optional. A category for the job template you are creating
                                                                  	Category *string
                                                                  
                                                                  	// Optional. A description of the job template you are creating.
                                                                  	Description *string
                                                                  
                                                                  	// Optional. Use queue hopping to avoid overly long waits in the backlog of the
                                                                  	// queue that you submit your job to. Specify an alternate queue and the maximum
                                                                  	// time that your job will wait in the initial queue before hopping. For more
                                                                  	// information about this feature, see the AWS Elemental MediaConvert User Guide.
                                                                  	HopDestinations []types.HopDestination
                                                                  
                                                                  	// Specify the relative priority for this job. In any given queue, the service
                                                                  	// begins processing the job with the highest value first. When more than one job
                                                                  	// has the same priority, the service begins processing the job that you submitted
                                                                  	// first. If you don't specify a priority, the service uses the default value 0.
                                                                  	Priority int32
                                                                  
                                                                  	// Optional. The queue that jobs created from this template are assigned to. If you
                                                                  	// don't specify this, jobs will go to the default queue.
                                                                  	Queue *string
                                                                  
                                                                  	// Specify how often MediaConvert sends STATUS_UPDATE events to Amazon CloudWatch
                                                                  	// Events. Set the interval, in seconds, between status updates. MediaConvert sends
                                                                  	// an update at this interval from the time the service begins processing your job
                                                                  	// to the time it completes the transcode or encounters an error.
                                                                  	StatusUpdateInterval types.StatusUpdateInterval
                                                                  
                                                                  	// The tags that you want to add to the resource. You can tag resources with a
                                                                  	// key-value pair or with only a key.
                                                                  	Tags map[string]string
                                                                  }

                                                                  type CreateJobTemplateOutput

                                                                  type CreateJobTemplateOutput struct {
                                                                  
                                                                  	// A job template is a pre-made set of encoding instructions that you can use to
                                                                  	// quickly create a job.
                                                                  	JobTemplate *types.JobTemplate
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type CreatePresetInput

                                                                  type CreatePresetInput struct {
                                                                  
                                                                  	// The name of the preset you are creating.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Name *string
                                                                  
                                                                  	// Settings for preset
                                                                  	//
                                                                  	// This member is required.
                                                                  	Settings *types.PresetSettings
                                                                  
                                                                  	// Optional. A category for the preset you are creating.
                                                                  	Category *string
                                                                  
                                                                  	// Optional. A description of the preset you are creating.
                                                                  	Description *string
                                                                  
                                                                  	// The tags that you want to add to the resource. You can tag resources with a
                                                                  	// key-value pair or with only a key.
                                                                  	Tags map[string]string
                                                                  }

                                                                  type CreatePresetOutput

                                                                  type CreatePresetOutput struct {
                                                                  
                                                                  	// A preset is a collection of preconfigured media conversion settings that you
                                                                  	// want MediaConvert to apply to the output during the conversion process.
                                                                  	Preset *types.Preset
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type CreateQueueInput

                                                                  type CreateQueueInput struct {
                                                                  
                                                                  	// The name of the queue that you are creating.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Name *string
                                                                  
                                                                  	// Optional. A description of the queue that you are creating.
                                                                  	Description *string
                                                                  
                                                                  	// Specifies whether the pricing plan for the queue is on-demand or reserved. For
                                                                  	// on-demand, you pay per minute, billed in increments of .01 minute. For reserved,
                                                                  	// you pay for the transcoding capacity of the entire queue, regardless of how much
                                                                  	// or how little you use it. Reserved pricing requires a 12-month commitment. When
                                                                  	// you use the API to create a queue, the default is on-demand.
                                                                  	PricingPlan types.PricingPlan
                                                                  
                                                                  	// Details about the pricing plan for your reserved queue. Required for reserved
                                                                  	// queues and not applicable to on-demand queues.
                                                                  	ReservationPlanSettings *types.ReservationPlanSettings
                                                                  
                                                                  	// Initial state of the queue. If you create a paused queue, then jobs in that
                                                                  	// queue won't begin.
                                                                  	Status types.QueueStatus
                                                                  
                                                                  	// The tags that you want to add to the resource. You can tag resources with a
                                                                  	// key-value pair or with only a key.
                                                                  	Tags map[string]string
                                                                  }

                                                                  type CreateQueueOutput

                                                                  type CreateQueueOutput struct {
                                                                  
                                                                  	// You can use queues to manage the resources that are available to your AWS
                                                                  	// account for running multiple transcoding jobs at the same time. If you don't
                                                                  	// specify a queue, the service sends all jobs through the default queue. For more
                                                                  	// information, see
                                                                  	// https://docs.aws.amazon.com/mediaconvert/latest/ug/working-with-queues.html.
                                                                  	Queue *types.Queue
                                                                  
                                                                  	// Metadata pertaining to the operation's result.
                                                                  	ResultMetadata middleware.Metadata
                                                                  }

                                                                  type DeleteJobTemplateInput

                                                                  type DeleteJobTemplateInput struct {
                                                                  
                                                                  	// The name of the job template to be deleted.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Name *string
                                                                  }

                                                                  type DeleteJobTemplateOutput

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

                                                                  type DeletePresetInput

                                                                  type DeletePresetInput struct {
                                                                  
                                                                  	// The name of the preset to be deleted.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Name *string
                                                                  }

                                                                  type DeletePresetOutput

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

                                                                  type DeleteQueueInput

                                                                  type DeleteQueueInput struct {
                                                                  
                                                                  	// The name of the queue that you want to delete.
                                                                  	//
                                                                  	// This member is required.
                                                                  	Name *string
                                                                  }

                                                                  type DeleteQueueOutput

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

                                                                  type DescribeEndpointsAPIClient

                                                                  type DescribeEndpointsAPIClient interface {
                                                                  	DescribeEndpoints(context.Context, *DescribeEndpointsInput, ...func(*Options)) (*DescribeEndpointsOutput, error)
                                                                  }

                                                                    DescribeEndpointsAPIClient is a client that implements the DescribeEndpoints operation.

                                                                    type DescribeEndpointsInput

                                                                    type DescribeEndpointsInput struct {
                                                                    
                                                                    	// Optional. Max number of endpoints, up to twenty, that will be returned at one
                                                                    	// time.
                                                                    	MaxResults int32
                                                                    
                                                                    	// Optional field, defaults to DEFAULT. Specify DEFAULT for this operation to
                                                                    	// return your endpoints if any exist, or to create an endpoint for you and return
                                                                    	// it if one doesn't already exist. Specify GET_ONLY to return your endpoints if
                                                                    	// any exist, or an empty list if none exist.
                                                                    	Mode types.DescribeEndpointsMode
                                                                    
                                                                    	// Use this string, provided with the response to a previous request, to request
                                                                    	// the next batch of endpoints.
                                                                    	NextToken *string
                                                                    }

                                                                      DescribeEndpointsRequest

                                                                      type DescribeEndpointsOutput

                                                                      type DescribeEndpointsOutput struct {
                                                                      
                                                                      	// List of endpoints
                                                                      	Endpoints []types.Endpoint
                                                                      
                                                                      	// Use this string to request the next batch of endpoints.
                                                                      	NextToken *string
                                                                      
                                                                      	// Metadata pertaining to the operation's result.
                                                                      	ResultMetadata middleware.Metadata
                                                                      }

                                                                      type DescribeEndpointsPaginator

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

                                                                        DescribeEndpointsPaginator is a paginator for DescribeEndpoints

                                                                        func NewDescribeEndpointsPaginator

                                                                        func NewDescribeEndpointsPaginator(client DescribeEndpointsAPIClient, params *DescribeEndpointsInput, optFns ...func(*DescribeEndpointsPaginatorOptions)) *DescribeEndpointsPaginator

                                                                          NewDescribeEndpointsPaginator returns a new DescribeEndpointsPaginator

                                                                          func (*DescribeEndpointsPaginator) HasMorePages

                                                                          func (p *DescribeEndpointsPaginator) HasMorePages() bool

                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                            func (*DescribeEndpointsPaginator) NextPage

                                                                            func (p *DescribeEndpointsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeEndpointsOutput, error)

                                                                              NextPage retrieves the next DescribeEndpoints page.

                                                                              type DescribeEndpointsPaginatorOptions

                                                                              type DescribeEndpointsPaginatorOptions struct {
                                                                              	// Optional. Max number of endpoints, up to twenty, that will be returned at one
                                                                              	// time.
                                                                              	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
                                                                              }

                                                                                DescribeEndpointsPaginatorOptions is the paginator options for DescribeEndpoints

                                                                                type DisassociateCertificateInput

                                                                                type DisassociateCertificateInput struct {
                                                                                
                                                                                	// The ARN of the ACM certificate that you want to disassociate from your
                                                                                	// MediaConvert resource.
                                                                                	//
                                                                                	// This member is required.
                                                                                	Arn *string
                                                                                }

                                                                                type DisassociateCertificateOutput

                                                                                type DisassociateCertificateOutput struct {
                                                                                	// 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 GetJobInput

                                                                                        type GetJobInput struct {
                                                                                        
                                                                                        	// the job ID of the job.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	Id *string
                                                                                        }

                                                                                        type GetJobOutput

                                                                                        type GetJobOutput struct {
                                                                                        
                                                                                        	// Each job converts an input file into an output file or files. For more
                                                                                        	// information, see the User Guide at
                                                                                        	// https://docs.aws.amazon.com/mediaconvert/latest/ug/what-is.html
                                                                                        	Job *types.Job
                                                                                        
                                                                                        	// Metadata pertaining to the operation's result.
                                                                                        	ResultMetadata middleware.Metadata
                                                                                        }

                                                                                        type GetJobTemplateInput

                                                                                        type GetJobTemplateInput struct {
                                                                                        
                                                                                        	// The name of the job template.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	Name *string
                                                                                        }

                                                                                        type GetJobTemplateOutput

                                                                                        type GetJobTemplateOutput struct {
                                                                                        
                                                                                        	// A job template is a pre-made set of encoding instructions that you can use to
                                                                                        	// quickly create a job.
                                                                                        	JobTemplate *types.JobTemplate
                                                                                        
                                                                                        	// Metadata pertaining to the operation's result.
                                                                                        	ResultMetadata middleware.Metadata
                                                                                        }

                                                                                        type GetPresetInput

                                                                                        type GetPresetInput struct {
                                                                                        
                                                                                        	// The name of the preset.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	Name *string
                                                                                        }

                                                                                        type GetPresetOutput

                                                                                        type GetPresetOutput struct {
                                                                                        
                                                                                        	// A preset is a collection of preconfigured media conversion settings that you
                                                                                        	// want MediaConvert to apply to the output during the conversion process.
                                                                                        	Preset *types.Preset
                                                                                        
                                                                                        	// Metadata pertaining to the operation's result.
                                                                                        	ResultMetadata middleware.Metadata
                                                                                        }

                                                                                        type GetQueueInput

                                                                                        type GetQueueInput struct {
                                                                                        
                                                                                        	// The name of the queue that you want information about.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	Name *string
                                                                                        }

                                                                                        type GetQueueOutput

                                                                                        type GetQueueOutput struct {
                                                                                        
                                                                                        	// You can use queues to manage the resources that are available to your AWS
                                                                                        	// account for running multiple transcoding jobs at the same time. If you don't
                                                                                        	// specify a queue, the service sends all jobs through the default queue. For more
                                                                                        	// information, see
                                                                                        	// https://docs.aws.amazon.com/mediaconvert/latest/ug/working-with-queues.html.
                                                                                        	Queue *types.Queue
                                                                                        
                                                                                        	// Metadata pertaining to the operation's result.
                                                                                        	ResultMetadata middleware.Metadata
                                                                                        }

                                                                                        type HTTPClient

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

                                                                                        type HTTPSignerV4

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

                                                                                        type IdempotencyTokenProvider

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

                                                                                          IdempotencyTokenProvider interface for providing idempotency token

                                                                                          type ListJobTemplatesAPIClient

                                                                                          type ListJobTemplatesAPIClient interface {
                                                                                          	ListJobTemplates(context.Context, *ListJobTemplatesInput, ...func(*Options)) (*ListJobTemplatesOutput, error)
                                                                                          }

                                                                                            ListJobTemplatesAPIClient is a client that implements the ListJobTemplates operation.

                                                                                            type ListJobTemplatesInput

                                                                                            type ListJobTemplatesInput struct {
                                                                                            
                                                                                            	// Optionally, specify a job template category to limit responses to only job
                                                                                            	// templates from that category.
                                                                                            	Category *string
                                                                                            
                                                                                            	// Optional. When you request a list of job templates, you can choose to list them
                                                                                            	// alphabetically by NAME or chronologically by CREATION_DATE. If you don't
                                                                                            	// specify, the service will list them by name.
                                                                                            	ListBy types.JobTemplateListBy
                                                                                            
                                                                                            	// Optional. Number of job templates, up to twenty, that will be returned at one
                                                                                            	// time.
                                                                                            	MaxResults int32
                                                                                            
                                                                                            	// Use this string, provided with the response to a previous request, to request
                                                                                            	// the next batch of job templates.
                                                                                            	NextToken *string
                                                                                            
                                                                                            	// Optional. When you request lists of resources, you can specify whether they are
                                                                                            	// sorted in ASCENDING or DESCENDING order. Default varies by resource.
                                                                                            	Order types.Order
                                                                                            }

                                                                                            type ListJobTemplatesOutput

                                                                                            type ListJobTemplatesOutput struct {
                                                                                            
                                                                                            	// List of Job templates.
                                                                                            	JobTemplates []types.JobTemplate
                                                                                            
                                                                                            	// Use this string to request the next batch of job templates.
                                                                                            	NextToken *string
                                                                                            
                                                                                            	// Metadata pertaining to the operation's result.
                                                                                            	ResultMetadata middleware.Metadata
                                                                                            }

                                                                                            type ListJobTemplatesPaginator

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

                                                                                              ListJobTemplatesPaginator is a paginator for ListJobTemplates

                                                                                              func NewListJobTemplatesPaginator

                                                                                              func NewListJobTemplatesPaginator(client ListJobTemplatesAPIClient, params *ListJobTemplatesInput, optFns ...func(*ListJobTemplatesPaginatorOptions)) *ListJobTemplatesPaginator

                                                                                                NewListJobTemplatesPaginator returns a new ListJobTemplatesPaginator

                                                                                                func (*ListJobTemplatesPaginator) HasMorePages

                                                                                                func (p *ListJobTemplatesPaginator) HasMorePages() bool

                                                                                                  HasMorePages returns a boolean indicating whether more pages are available

                                                                                                  func (*ListJobTemplatesPaginator) NextPage

                                                                                                  func (p *ListJobTemplatesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListJobTemplatesOutput, error)

                                                                                                    NextPage retrieves the next ListJobTemplates page.

                                                                                                    type ListJobTemplatesPaginatorOptions

                                                                                                    type ListJobTemplatesPaginatorOptions struct {
                                                                                                    	// Optional. Number of job templates, up to twenty, that will be returned at one
                                                                                                    	// time.
                                                                                                    	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
                                                                                                    }

                                                                                                      ListJobTemplatesPaginatorOptions is the paginator options for ListJobTemplates

                                                                                                      type ListJobsAPIClient

                                                                                                      type ListJobsAPIClient interface {
                                                                                                      	ListJobs(context.Context, *ListJobsInput, ...func(*Options)) (*ListJobsOutput, error)
                                                                                                      }

                                                                                                        ListJobsAPIClient is a client that implements the ListJobs operation.

                                                                                                        type ListJobsInput

                                                                                                        type ListJobsInput struct {
                                                                                                        
                                                                                                        	// Optional. Number of jobs, up to twenty, that will be returned at one time.
                                                                                                        	MaxResults int32
                                                                                                        
                                                                                                        	// Optional. Use this string, provided with the response to a previous request, to
                                                                                                        	// request the next batch of jobs.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Optional. When you request lists of resources, you can specify whether they are
                                                                                                        	// sorted in ASCENDING or DESCENDING order. Default varies by resource.
                                                                                                        	Order types.Order
                                                                                                        
                                                                                                        	// Optional. Provide a queue name to get back only jobs from that queue.
                                                                                                        	Queue *string
                                                                                                        
                                                                                                        	// Optional. A job's status can be SUBMITTED, PROGRESSING, COMPLETE, CANCELED, or
                                                                                                        	// ERROR.
                                                                                                        	Status types.JobStatus
                                                                                                        }

                                                                                                        type ListJobsOutput

                                                                                                        type ListJobsOutput struct {
                                                                                                        
                                                                                                        	// List of jobs
                                                                                                        	Jobs []types.Job
                                                                                                        
                                                                                                        	// Use this string to request the next batch of jobs.
                                                                                                        	NextToken *string
                                                                                                        
                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                        }

                                                                                                        type ListJobsPaginator

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

                                                                                                          ListJobsPaginator is a paginator for ListJobs

                                                                                                          func NewListJobsPaginator

                                                                                                          func NewListJobsPaginator(client ListJobsAPIClient, params *ListJobsInput, optFns ...func(*ListJobsPaginatorOptions)) *ListJobsPaginator

                                                                                                            NewListJobsPaginator returns a new ListJobsPaginator

                                                                                                            func (*ListJobsPaginator) HasMorePages

                                                                                                            func (p *ListJobsPaginator) HasMorePages() bool

                                                                                                              HasMorePages returns a boolean indicating whether more pages are available

                                                                                                              func (*ListJobsPaginator) NextPage

                                                                                                              func (p *ListJobsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListJobsOutput, error)

                                                                                                                NextPage retrieves the next ListJobs page.

                                                                                                                type ListJobsPaginatorOptions

                                                                                                                type ListJobsPaginatorOptions struct {
                                                                                                                	// Optional. Number of jobs, up to twenty, that will be returned at one time.
                                                                                                                	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
                                                                                                                }

                                                                                                                  ListJobsPaginatorOptions is the paginator options for ListJobs

                                                                                                                  type ListPresetsAPIClient

                                                                                                                  type ListPresetsAPIClient interface {
                                                                                                                  	ListPresets(context.Context, *ListPresetsInput, ...func(*Options)) (*ListPresetsOutput, error)
                                                                                                                  }

                                                                                                                    ListPresetsAPIClient is a client that implements the ListPresets operation.

                                                                                                                    type ListPresetsInput

                                                                                                                    type ListPresetsInput struct {
                                                                                                                    
                                                                                                                    	// Optionally, specify a preset category to limit responses to only presets from
                                                                                                                    	// that category.
                                                                                                                    	Category *string
                                                                                                                    
                                                                                                                    	// Optional. When you request a list of presets, you can choose to list them
                                                                                                                    	// alphabetically by NAME or chronologically by CREATION_DATE. If you don't
                                                                                                                    	// specify, the service will list them by name.
                                                                                                                    	ListBy types.PresetListBy
                                                                                                                    
                                                                                                                    	// Optional. Number of presets, up to twenty, that will be returned at one time
                                                                                                                    	MaxResults int32
                                                                                                                    
                                                                                                                    	// Use this string, provided with the response to a previous request, to request
                                                                                                                    	// the next batch of presets.
                                                                                                                    	NextToken *string
                                                                                                                    
                                                                                                                    	// Optional. When you request lists of resources, you can specify whether they are
                                                                                                                    	// sorted in ASCENDING or DESCENDING order. Default varies by resource.
                                                                                                                    	Order types.Order
                                                                                                                    }

                                                                                                                    type ListPresetsOutput

                                                                                                                    type ListPresetsOutput struct {
                                                                                                                    
                                                                                                                    	// Use this string to request the next batch of presets.
                                                                                                                    	NextToken *string
                                                                                                                    
                                                                                                                    	// List of presets
                                                                                                                    	Presets []types.Preset
                                                                                                                    
                                                                                                                    	// Metadata pertaining to the operation's result.
                                                                                                                    	ResultMetadata middleware.Metadata
                                                                                                                    }

                                                                                                                    type ListPresetsPaginator

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

                                                                                                                      ListPresetsPaginator is a paginator for ListPresets

                                                                                                                      func NewListPresetsPaginator

                                                                                                                      func NewListPresetsPaginator(client ListPresetsAPIClient, params *ListPresetsInput, optFns ...func(*ListPresetsPaginatorOptions)) *ListPresetsPaginator

                                                                                                                        NewListPresetsPaginator returns a new ListPresetsPaginator

                                                                                                                        func (*ListPresetsPaginator) HasMorePages

                                                                                                                        func (p *ListPresetsPaginator) HasMorePages() bool

                                                                                                                          HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                          func (*ListPresetsPaginator) NextPage

                                                                                                                          func (p *ListPresetsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListPresetsOutput, error)

                                                                                                                            NextPage retrieves the next ListPresets page.

                                                                                                                            type ListPresetsPaginatorOptions

                                                                                                                            type ListPresetsPaginatorOptions struct {
                                                                                                                            	// Optional. Number of presets, up to twenty, that will be returned at one time
                                                                                                                            	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
                                                                                                                            }

                                                                                                                              ListPresetsPaginatorOptions is the paginator options for ListPresets

                                                                                                                              type ListQueuesAPIClient

                                                                                                                              type ListQueuesAPIClient interface {
                                                                                                                              	ListQueues(context.Context, *ListQueuesInput, ...func(*Options)) (*ListQueuesOutput, error)
                                                                                                                              }

                                                                                                                                ListQueuesAPIClient is a client that implements the ListQueues operation.

                                                                                                                                type ListQueuesInput

                                                                                                                                type ListQueuesInput struct {
                                                                                                                                
                                                                                                                                	// Optional. When you request a list of queues, you can choose to list them
                                                                                                                                	// alphabetically by NAME or chronologically by CREATION_DATE. If you don't
                                                                                                                                	// specify, the service will list them by creation date.
                                                                                                                                	ListBy types.QueueListBy
                                                                                                                                
                                                                                                                                	// Optional. Number of queues, up to twenty, that will be returned at one time.
                                                                                                                                	MaxResults int32
                                                                                                                                
                                                                                                                                	// Use this string, provided with the response to a previous request, to request
                                                                                                                                	// the next batch of queues.
                                                                                                                                	NextToken *string
                                                                                                                                
                                                                                                                                	// Optional. When you request lists of resources, you can specify whether they are
                                                                                                                                	// sorted in ASCENDING or DESCENDING order. Default varies by resource.
                                                                                                                                	Order types.Order
                                                                                                                                }

                                                                                                                                type ListQueuesOutput

                                                                                                                                type ListQueuesOutput struct {
                                                                                                                                
                                                                                                                                	// Use this string to request the next batch of queues.
                                                                                                                                	NextToken *string
                                                                                                                                
                                                                                                                                	// List of queues.
                                                                                                                                	Queues []types.Queue
                                                                                                                                
                                                                                                                                	// Metadata pertaining to the operation's result.
                                                                                                                                	ResultMetadata middleware.Metadata
                                                                                                                                }

                                                                                                                                type ListQueuesPaginator

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

                                                                                                                                  ListQueuesPaginator is a paginator for ListQueues

                                                                                                                                  func NewListQueuesPaginator

                                                                                                                                  func NewListQueuesPaginator(client ListQueuesAPIClient, params *ListQueuesInput, optFns ...func(*ListQueuesPaginatorOptions)) *ListQueuesPaginator

                                                                                                                                    NewListQueuesPaginator returns a new ListQueuesPaginator

                                                                                                                                    func (*ListQueuesPaginator) HasMorePages

                                                                                                                                    func (p *ListQueuesPaginator) HasMorePages() bool

                                                                                                                                      HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                                      func (*ListQueuesPaginator) NextPage

                                                                                                                                      func (p *ListQueuesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListQueuesOutput, error)

                                                                                                                                        NextPage retrieves the next ListQueues page.

                                                                                                                                        type ListQueuesPaginatorOptions

                                                                                                                                        type ListQueuesPaginatorOptions struct {
                                                                                                                                        	// Optional. Number of queues, up to twenty, that will be returned at one time.
                                                                                                                                        	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
                                                                                                                                        }

                                                                                                                                          ListQueuesPaginatorOptions is the paginator options for ListQueues

                                                                                                                                          type ListTagsForResourceInput

                                                                                                                                          type ListTagsForResourceInput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) of the resource that you want to list tags for.
                                                                                                                                          	// To get the ARN, send a GET request with the resource name.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	Arn *string
                                                                                                                                          }

                                                                                                                                          type ListTagsForResourceOutput

                                                                                                                                          type ListTagsForResourceOutput struct {
                                                                                                                                          
                                                                                                                                          	// The Amazon Resource Name (ARN) and tags for an AWS Elemental MediaConvert
                                                                                                                                          	// resource.
                                                                                                                                          	ResourceTags *types.ResourceTags
                                                                                                                                          
                                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                                          }

                                                                                                                                          type Options

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

                                                                                                                                          func (Options) Copy

                                                                                                                                          func (o Options) Copy() Options

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

                                                                                                                                            type ResolveEndpoint

                                                                                                                                            type ResolveEndpoint struct {
                                                                                                                                            	Resolver EndpointResolver
                                                                                                                                            	Options  EndpointResolverOptions
                                                                                                                                            }

                                                                                                                                            func (*ResolveEndpoint) HandleSerialize

                                                                                                                                            func (*ResolveEndpoint) ID

                                                                                                                                            func (*ResolveEndpoint) ID() string

                                                                                                                                            type TagResourceInput

                                                                                                                                            type TagResourceInput struct {
                                                                                                                                            
                                                                                                                                            	// The Amazon Resource Name (ARN) of the resource that you want to tag. To get the
                                                                                                                                            	// ARN, send a GET request with the resource name.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	Arn *string
                                                                                                                                            
                                                                                                                                            	// The tags that you want to add to the resource. You can tag resources with a
                                                                                                                                            	// key-value pair or with only a key.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	Tags map[string]string
                                                                                                                                            }

                                                                                                                                            type TagResourceOutput

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

                                                                                                                                            type UntagResourceInput

                                                                                                                                            type UntagResourceInput struct {
                                                                                                                                            
                                                                                                                                            	// The Amazon Resource Name (ARN) of the resource that you want to remove tags
                                                                                                                                            	// from. To get the ARN, send a GET request with the resource name.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	Arn *string
                                                                                                                                            
                                                                                                                                            	// The keys of the tags that you want to remove from the resource.
                                                                                                                                            	TagKeys []string
                                                                                                                                            }

                                                                                                                                            type UntagResourceOutput

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

                                                                                                                                            type UpdateJobTemplateInput

                                                                                                                                            type UpdateJobTemplateInput struct {
                                                                                                                                            
                                                                                                                                            	// The name of the job template you are modifying
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	Name *string
                                                                                                                                            
                                                                                                                                            	// Accelerated transcoding can significantly speed up jobs with long, visually
                                                                                                                                            	// complex content. Outputs that use this feature incur pro-tier pricing. For
                                                                                                                                            	// information about feature limitations, see the AWS Elemental MediaConvert User
                                                                                                                                            	// Guide.
                                                                                                                                            	AccelerationSettings *types.AccelerationSettings
                                                                                                                                            
                                                                                                                                            	// The new category for the job template, if you are changing it.
                                                                                                                                            	Category *string
                                                                                                                                            
                                                                                                                                            	// The new description for the job template, if you are changing it.
                                                                                                                                            	Description *string
                                                                                                                                            
                                                                                                                                            	// Optional list of hop destinations.
                                                                                                                                            	HopDestinations []types.HopDestination
                                                                                                                                            
                                                                                                                                            	// Specify the relative priority for this job. In any given queue, the service
                                                                                                                                            	// begins processing the job with the highest value first. When more than one job
                                                                                                                                            	// has the same priority, the service begins processing the job that you submitted
                                                                                                                                            	// first. If you don't specify a priority, the service uses the default value 0.
                                                                                                                                            	Priority int32
                                                                                                                                            
                                                                                                                                            	// The new queue for the job template, if you are changing it.
                                                                                                                                            	Queue *string
                                                                                                                                            
                                                                                                                                            	// JobTemplateSettings contains all the transcode settings saved in the template
                                                                                                                                            	// that will be applied to jobs created from it.
                                                                                                                                            	Settings *types.JobTemplateSettings
                                                                                                                                            
                                                                                                                                            	// Specify how often MediaConvert sends STATUS_UPDATE events to Amazon CloudWatch
                                                                                                                                            	// Events. Set the interval, in seconds, between status updates. MediaConvert sends
                                                                                                                                            	// an update at this interval from the time the service begins processing your job
                                                                                                                                            	// to the time it completes the transcode or encounters an error.
                                                                                                                                            	StatusUpdateInterval types.StatusUpdateInterval
                                                                                                                                            }

                                                                                                                                            type UpdateJobTemplateOutput

                                                                                                                                            type UpdateJobTemplateOutput struct {
                                                                                                                                            
                                                                                                                                            	// A job template is a pre-made set of encoding instructions that you can use to
                                                                                                                                            	// quickly create a job.
                                                                                                                                            	JobTemplate *types.JobTemplate
                                                                                                                                            
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type UpdatePresetInput

                                                                                                                                            type UpdatePresetInput struct {
                                                                                                                                            
                                                                                                                                            	// The name of the preset you are modifying.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	Name *string
                                                                                                                                            
                                                                                                                                            	// The new category for the preset, if you are changing it.
                                                                                                                                            	Category *string
                                                                                                                                            
                                                                                                                                            	// The new description for the preset, if you are changing it.
                                                                                                                                            	Description *string
                                                                                                                                            
                                                                                                                                            	// Settings for preset
                                                                                                                                            	Settings *types.PresetSettings
                                                                                                                                            }

                                                                                                                                            type UpdatePresetOutput

                                                                                                                                            type UpdatePresetOutput struct {
                                                                                                                                            
                                                                                                                                            	// A preset is a collection of preconfigured media conversion settings that you
                                                                                                                                            	// want MediaConvert to apply to the output during the conversion process.
                                                                                                                                            	Preset *types.Preset
                                                                                                                                            
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            type UpdateQueueInput

                                                                                                                                            type UpdateQueueInput struct {
                                                                                                                                            
                                                                                                                                            	// The name of the queue that you are modifying.
                                                                                                                                            	//
                                                                                                                                            	// This member is required.
                                                                                                                                            	Name *string
                                                                                                                                            
                                                                                                                                            	// The new description for the queue, if you are changing it.
                                                                                                                                            	Description *string
                                                                                                                                            
                                                                                                                                            	// The new details of your pricing plan for your reserved queue. When you set up a
                                                                                                                                            	// new pricing plan to replace an expired one, you enter into another 12-month
                                                                                                                                            	// commitment. When you add capacity to your queue by increasing the number of RTS,
                                                                                                                                            	// you extend the term of your commitment to 12 months from when you add capacity.
                                                                                                                                            	// After you make these commitments, you can't cancel them.
                                                                                                                                            	ReservationPlanSettings *types.ReservationPlanSettings
                                                                                                                                            
                                                                                                                                            	// Pause or activate a queue by changing its status between ACTIVE and PAUSED. If
                                                                                                                                            	// you pause a queue, jobs in that queue won't begin. Jobs that are running when
                                                                                                                                            	// you pause the queue continue to run until they finish or result in an error.
                                                                                                                                            	Status types.QueueStatus
                                                                                                                                            }

                                                                                                                                            type UpdateQueueOutput

                                                                                                                                            type UpdateQueueOutput struct {
                                                                                                                                            
                                                                                                                                            	// You can use queues to manage the resources that are available to your AWS
                                                                                                                                            	// account for running multiple transcoding jobs at the same time. If you don't
                                                                                                                                            	// specify a queue, the service sends all jobs through the default queue. For more
                                                                                                                                            	// information, see
                                                                                                                                            	// https://docs.aws.amazon.com/mediaconvert/latest/ug/working-with-queues.html.
                                                                                                                                            	Queue *types.Queue
                                                                                                                                            
                                                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                                                            }

                                                                                                                                            Directories

                                                                                                                                            Path Synopsis
                                                                                                                                            internal