logo

Trait rusoto_medialive::MediaLive

source · [−]
pub trait MediaLive {

Show 56 methods    fn accept_input_device_transfer<'life0, 'async_trait>(
        &'life0 self, 
        input: AcceptInputDeviceTransferRequest
    ) -> Pin<Box<dyn Future<Output = Result<AcceptInputDeviceTransferResponse, RusotoError<AcceptInputDeviceTransferError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn batch_delete<'life0, 'async_trait>(
        &'life0 self, 
        input: BatchDeleteRequest
    ) -> Pin<Box<dyn Future<Output = Result<BatchDeleteResponse, RusotoError<BatchDeleteError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn batch_start<'life0, 'async_trait>(
        &'life0 self, 
        input: BatchStartRequest
    ) -> Pin<Box<dyn Future<Output = Result<BatchStartResponse, RusotoError<BatchStartError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn batch_stop<'life0, 'async_trait>(
        &'life0 self, 
        input: BatchStopRequest
    ) -> Pin<Box<dyn Future<Output = Result<BatchStopResponse, RusotoError<BatchStopError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn batch_update_schedule<'life0, 'async_trait>(
        &'life0 self, 
        input: BatchUpdateScheduleRequest
    ) -> Pin<Box<dyn Future<Output = Result<BatchUpdateScheduleResponse, RusotoError<BatchUpdateScheduleError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn cancel_input_device_transfer<'life0, 'async_trait>(
        &'life0 self, 
        input: CancelInputDeviceTransferRequest
    ) -> Pin<Box<dyn Future<Output = Result<CancelInputDeviceTransferResponse, RusotoError<CancelInputDeviceTransferError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn create_channel<'life0, 'async_trait>(
        &'life0 self, 
        input: CreateChannelRequest
    ) -> Pin<Box<dyn Future<Output = Result<CreateChannelResponse, RusotoError<CreateChannelError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn create_input<'life0, 'async_trait>(
        &'life0 self, 
        input: CreateInputRequest
    ) -> Pin<Box<dyn Future<Output = Result<CreateInputResponse, RusotoError<CreateInputError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn create_input_security_group<'life0, 'async_trait>(
        &'life0 self, 
        input: CreateInputSecurityGroupRequest
    ) -> Pin<Box<dyn Future<Output = Result<CreateInputSecurityGroupResponse, RusotoError<CreateInputSecurityGroupError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn create_multiplex<'life0, 'async_trait>(
        &'life0 self, 
        input: CreateMultiplexRequest
    ) -> Pin<Box<dyn Future<Output = Result<CreateMultiplexResponse, RusotoError<CreateMultiplexError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn create_multiplex_program<'life0, 'async_trait>(
        &'life0 self, 
        input: CreateMultiplexProgramRequest
    ) -> Pin<Box<dyn Future<Output = Result<CreateMultiplexProgramResponse, RusotoError<CreateMultiplexProgramError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn create_partner_input<'life0, 'async_trait>(
        &'life0 self, 
        input: CreatePartnerInputRequest
    ) -> Pin<Box<dyn Future<Output = Result<CreatePartnerInputResponse, RusotoError<CreatePartnerInputError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn create_tags<'life0, 'async_trait>(
        &'life0 self, 
        input: CreateTagsRequest
    ) -> Pin<Box<dyn Future<Output = Result<(), RusotoError<CreateTagsError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn delete_channel<'life0, 'async_trait>(
        &'life0 self, 
        input: DeleteChannelRequest
    ) -> Pin<Box<dyn Future<Output = Result<DeleteChannelResponse, RusotoError<DeleteChannelError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn delete_input<'life0, 'async_trait>(
        &'life0 self, 
        input: DeleteInputRequest
    ) -> Pin<Box<dyn Future<Output = Result<DeleteInputResponse, RusotoError<DeleteInputError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn delete_input_security_group<'life0, 'async_trait>(
        &'life0 self, 
        input: DeleteInputSecurityGroupRequest
    ) -> Pin<Box<dyn Future<Output = Result<DeleteInputSecurityGroupResponse, RusotoError<DeleteInputSecurityGroupError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn delete_multiplex<'life0, 'async_trait>(
        &'life0 self, 
        input: DeleteMultiplexRequest
    ) -> Pin<Box<dyn Future<Output = Result<DeleteMultiplexResponse, RusotoError<DeleteMultiplexError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn delete_multiplex_program<'life0, 'async_trait>(
        &'life0 self, 
        input: DeleteMultiplexProgramRequest
    ) -> Pin<Box<dyn Future<Output = Result<DeleteMultiplexProgramResponse, RusotoError<DeleteMultiplexProgramError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn delete_reservation<'life0, 'async_trait>(
        &'life0 self, 
        input: DeleteReservationRequest
    ) -> Pin<Box<dyn Future<Output = Result<DeleteReservationResponse, RusotoError<DeleteReservationError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn delete_schedule<'life0, 'async_trait>(
        &'life0 self, 
        input: DeleteScheduleRequest
    ) -> Pin<Box<dyn Future<Output = Result<DeleteScheduleResponse, RusotoError<DeleteScheduleError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn delete_tags<'life0, 'async_trait>(
        &'life0 self, 
        input: DeleteTagsRequest
    ) -> Pin<Box<dyn Future<Output = Result<(), RusotoError<DeleteTagsError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn describe_channel<'life0, 'async_trait>(
        &'life0 self, 
        input: DescribeChannelRequest
    ) -> Pin<Box<dyn Future<Output = Result<DescribeChannelResponse, RusotoError<DescribeChannelError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn describe_input<'life0, 'async_trait>(
        &'life0 self, 
        input: DescribeInputRequest
    ) -> Pin<Box<dyn Future<Output = Result<DescribeInputResponse, RusotoError<DescribeInputError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn describe_input_device<'life0, 'async_trait>(
        &'life0 self, 
        input: DescribeInputDeviceRequest
    ) -> Pin<Box<dyn Future<Output = Result<DescribeInputDeviceResponse, RusotoError<DescribeInputDeviceError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn describe_input_device_thumbnail<'life0, 'async_trait>(
        &'life0 self, 
        input: DescribeInputDeviceThumbnailRequest
    ) -> Pin<Box<dyn Future<Output = Result<DescribeInputDeviceThumbnailResponse, RusotoError<DescribeInputDeviceThumbnailError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn describe_input_security_group<'life0, 'async_trait>(
        &'life0 self, 
        input: DescribeInputSecurityGroupRequest
    ) -> Pin<Box<dyn Future<Output = Result<DescribeInputSecurityGroupResponse, RusotoError<DescribeInputSecurityGroupError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn describe_multiplex<'life0, 'async_trait>(
        &'life0 self, 
        input: DescribeMultiplexRequest
    ) -> Pin<Box<dyn Future<Output = Result<DescribeMultiplexResponse, RusotoError<DescribeMultiplexError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn describe_multiplex_program<'life0, 'async_trait>(
        &'life0 self, 
        input: DescribeMultiplexProgramRequest
    ) -> Pin<Box<dyn Future<Output = Result<DescribeMultiplexProgramResponse, RusotoError<DescribeMultiplexProgramError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn describe_offering<'life0, 'async_trait>(
        &'life0 self, 
        input: DescribeOfferingRequest
    ) -> Pin<Box<dyn Future<Output = Result<DescribeOfferingResponse, RusotoError<DescribeOfferingError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn describe_reservation<'life0, 'async_trait>(
        &'life0 self, 
        input: DescribeReservationRequest
    ) -> Pin<Box<dyn Future<Output = Result<DescribeReservationResponse, RusotoError<DescribeReservationError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn describe_schedule<'life0, 'async_trait>(
        &'life0 self, 
        input: DescribeScheduleRequest
    ) -> Pin<Box<dyn Future<Output = Result<DescribeScheduleResponse, RusotoError<DescribeScheduleError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn list_channels<'life0, 'async_trait>(
        &'life0 self, 
        input: ListChannelsRequest
    ) -> Pin<Box<dyn Future<Output = Result<ListChannelsResponse, RusotoError<ListChannelsError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn list_input_device_transfers<'life0, 'async_trait>(
        &'life0 self, 
        input: ListInputDeviceTransfersRequest
    ) -> Pin<Box<dyn Future<Output = Result<ListInputDeviceTransfersResponse, RusotoError<ListInputDeviceTransfersError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn list_input_devices<'life0, 'async_trait>(
        &'life0 self, 
        input: ListInputDevicesRequest
    ) -> Pin<Box<dyn Future<Output = Result<ListInputDevicesResponse, RusotoError<ListInputDevicesError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn list_input_security_groups<'life0, 'async_trait>(
        &'life0 self, 
        input: ListInputSecurityGroupsRequest
    ) -> Pin<Box<dyn Future<Output = Result<ListInputSecurityGroupsResponse, RusotoError<ListInputSecurityGroupsError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn list_inputs<'life0, 'async_trait>(
        &'life0 self, 
        input: ListInputsRequest
    ) -> Pin<Box<dyn Future<Output = Result<ListInputsResponse, RusotoError<ListInputsError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn list_multiplex_programs<'life0, 'async_trait>(
        &'life0 self, 
        input: ListMultiplexProgramsRequest
    ) -> Pin<Box<dyn Future<Output = Result<ListMultiplexProgramsResponse, RusotoError<ListMultiplexProgramsError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn list_multiplexes<'life0, 'async_trait>(
        &'life0 self, 
        input: ListMultiplexesRequest
    ) -> Pin<Box<dyn Future<Output = Result<ListMultiplexesResponse, RusotoError<ListMultiplexesError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn list_offerings<'life0, 'async_trait>(
        &'life0 self, 
        input: ListOfferingsRequest
    ) -> Pin<Box<dyn Future<Output = Result<ListOfferingsResponse, RusotoError<ListOfferingsError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn list_reservations<'life0, 'async_trait>(
        &'life0 self, 
        input: ListReservationsRequest
    ) -> Pin<Box<dyn Future<Output = Result<ListReservationsResponse, RusotoError<ListReservationsError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn list_tags_for_resource<'life0, 'async_trait>(
        &'life0 self, 
        input: ListTagsForResourceRequest
    ) -> Pin<Box<dyn Future<Output = Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn purchase_offering<'life0, 'async_trait>(
        &'life0 self, 
        input: PurchaseOfferingRequest
    ) -> Pin<Box<dyn Future<Output = Result<PurchaseOfferingResponse, RusotoError<PurchaseOfferingError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn reject_input_device_transfer<'life0, 'async_trait>(
        &'life0 self, 
        input: RejectInputDeviceTransferRequest
    ) -> Pin<Box<dyn Future<Output = Result<RejectInputDeviceTransferResponse, RusotoError<RejectInputDeviceTransferError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn start_channel<'life0, 'async_trait>(
        &'life0 self, 
        input: StartChannelRequest
    ) -> Pin<Box<dyn Future<Output = Result<StartChannelResponse, RusotoError<StartChannelError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn start_multiplex<'life0, 'async_trait>(
        &'life0 self, 
        input: StartMultiplexRequest
    ) -> Pin<Box<dyn Future<Output = Result<StartMultiplexResponse, RusotoError<StartMultiplexError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn stop_channel<'life0, 'async_trait>(
        &'life0 self, 
        input: StopChannelRequest
    ) -> Pin<Box<dyn Future<Output = Result<StopChannelResponse, RusotoError<StopChannelError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn stop_multiplex<'life0, 'async_trait>(
        &'life0 self, 
        input: StopMultiplexRequest
    ) -> Pin<Box<dyn Future<Output = Result<StopMultiplexResponse, RusotoError<StopMultiplexError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn transfer_input_device<'life0, 'async_trait>(
        &'life0 self, 
        input: TransferInputDeviceRequest
    ) -> Pin<Box<dyn Future<Output = Result<TransferInputDeviceResponse, RusotoError<TransferInputDeviceError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn update_channel<'life0, 'async_trait>(
        &'life0 self, 
        input: UpdateChannelRequest
    ) -> Pin<Box<dyn Future<Output = Result<UpdateChannelResponse, RusotoError<UpdateChannelError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn update_channel_class<'life0, 'async_trait>(
        &'life0 self, 
        input: UpdateChannelClassRequest
    ) -> Pin<Box<dyn Future<Output = Result<UpdateChannelClassResponse, RusotoError<UpdateChannelClassError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn update_input<'life0, 'async_trait>(
        &'life0 self, 
        input: UpdateInputRequest
    ) -> Pin<Box<dyn Future<Output = Result<UpdateInputResponse, RusotoError<UpdateInputError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn update_input_device<'life0, 'async_trait>(
        &'life0 self, 
        input: UpdateInputDeviceRequest
    ) -> Pin<Box<dyn Future<Output = Result<UpdateInputDeviceResponse, RusotoError<UpdateInputDeviceError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn update_input_security_group<'life0, 'async_trait>(
        &'life0 self, 
        input: UpdateInputSecurityGroupRequest
    ) -> Pin<Box<dyn Future<Output = Result<UpdateInputSecurityGroupResponse, RusotoError<UpdateInputSecurityGroupError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn update_multiplex<'life0, 'async_trait>(
        &'life0 self, 
        input: UpdateMultiplexRequest
    ) -> Pin<Box<dyn Future<Output = Result<UpdateMultiplexResponse, RusotoError<UpdateMultiplexError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn update_multiplex_program<'life0, 'async_trait>(
        &'life0 self, 
        input: UpdateMultiplexProgramRequest
    ) -> Pin<Box<dyn Future<Output = Result<UpdateMultiplexProgramResponse, RusotoError<UpdateMultiplexProgramError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
    fn update_reservation<'life0, 'async_trait>(
        &'life0 self, 
        input: UpdateReservationRequest
    ) -> Pin<Box<dyn Future<Output = Result<UpdateReservationResponse, RusotoError<UpdateReservationError>>> + Send + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;

}
Expand description

Trait representing the capabilities of the MediaLive API. MediaLive clients implement this trait.

Required Methods

Accept an incoming input device transfer. The ownership of the device will transfer to your AWS account.

Starts delete of resources.

Starts existing resources

Stops running resources

Update a channel schedule

Cancel an input device transfer that you have requested.

Creates a new channel

Create an input

Creates a Input Security Group

Create a new multiplex.

Create a new program in the multiplex.

Create a partner input

Create tags for a resource

Starts deletion of channel. The associated outputs are also deleted.

Deletes the input end point

Deletes an Input Security Group

Delete a multiplex. The multiplex must be idle.

Delete a program from a multiplex.

Delete an expired reservation.

Delete all schedule actions on a channel.

Removes tags for a resource

Gets details about a channel

Produces details about an input

Gets the details for the input device

Get the latest thumbnail data for the input device.

Produces a summary of an Input Security Group

Gets details about a multiplex.

Get the details for a program in a multiplex.

Get details for an offering.

Get details for a reservation.

Get a channel schedule

Produces list of channels that have been created

List input devices that are currently being transferred. List input devices that you are transferring from your AWS account or input devices that another AWS account is transferring to you.

List input devices

Produces a list of Input Security Groups for an account

Produces list of inputs that have been created

List the programs that currently exist for a specific multiplex.

Retrieve a list of the existing multiplexes.

List offerings available for purchase.

List purchased reservations.

Produces list of tags that have been created for a resource

Purchase an offering and create a reservation.

Reject the transfer of the specified input device to your AWS account.

Starts an existing channel

Start (run) the multiplex. Starting the multiplex does not start the channels. You must explicitly start each channel.

Stops a running channel

Stops a running multiplex. If the multiplex isn't running, this action has no effect.

Start an input device transfer to another AWS account. After you make the request, the other account must accept or reject the transfer.

Updates a channel.

Changes the class of the channel.

Updates an input.

Updates the parameters for the input device.

Update an Input Security Group's Whilelists.

Updates a multiplex.

Update a program in a multiplex.

Update reservation.

Implementors