@aws-sdk/client-mediatailor 3.50.0 → 3.51.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1571 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export declare enum MessageType {
+    SPLICE_INSERT = "SPLICE_INSERT"
+}
+
+export interface SlateSource {
+    
+    SourceLocationName?: string;
+    
+    VodSourceName?: string;
+}
+export declare namespace SlateSource {
+    
+    const filterSensitiveLog: (obj: SlateSource) => any;
+}
+
+export interface SpliceInsertMessage {
+    
+    AvailNum?: number;
+    
+    AvailsExpected?: number;
+    
+    SpliceEventId?: number;
+    
+    UniqueProgramId?: number;
+}
+export declare namespace SpliceInsertMessage {
+    
+    const filterSensitiveLog: (obj: SpliceInsertMessage) => any;
+}
+
+export interface AdBreak {
+    
+    MessageType?: MessageType | string;
+    
+    OffsetMillis?: number;
+    
+    Slate?: SlateSource;
+    
+    SpliceInsertMessage?: SpliceInsertMessage;
+}
+export declare namespace AdBreak {
+    
+    const filterSensitiveLog: (obj: AdBreak) => any;
+}
+
+export interface Alert {
+    
+    AlertCode: string | undefined;
+    
+    AlertMessage: string | undefined;
+    
+    LastModifiedTime: Date | undefined;
+    
+    RelatedResourceArns: string[] | undefined;
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace Alert {
+    
+    const filterSensitiveLog: (obj: Alert) => any;
+}
+export declare enum Operator {
+    EQUALS = "EQUALS"
+}
+
+export interface AvailMatchingCriteria {
+    
+    DynamicVariable: string | undefined;
+    
+    Operator: Operator | string | undefined;
+}
+export declare namespace AvailMatchingCriteria {
+    
+    const filterSensitiveLog: (obj: AvailMatchingCriteria) => any;
+}
+
+export interface DashPlaylistSettings {
+    
+    ManifestWindowSeconds?: number;
+    
+    MinBufferTimeSeconds?: number;
+    
+    MinUpdatePeriodSeconds?: number;
+    
+    SuggestedPresentationDelaySeconds?: number;
+}
+export declare namespace DashPlaylistSettings {
+    
+    const filterSensitiveLog: (obj: DashPlaylistSettings) => any;
+}
+
+export interface HlsPlaylistSettings {
+    
+    ManifestWindowSeconds?: number;
+}
+export declare namespace HlsPlaylistSettings {
+    
+    const filterSensitiveLog: (obj: HlsPlaylistSettings) => any;
+}
+
+export interface ResponseOutputItem {
+    
+    DashPlaylistSettings?: DashPlaylistSettings;
+    
+    HlsPlaylistSettings?: HlsPlaylistSettings;
+    
+    ManifestName: string | undefined;
+    
+    PlaybackUrl: string | undefined;
+    
+    SourceGroup: string | undefined;
+}
+export declare namespace ResponseOutputItem {
+    
+    const filterSensitiveLog: (obj: ResponseOutputItem) => any;
+}
+
+export interface Channel {
+    
+    Arn: string | undefined;
+    
+    ChannelName: string | undefined;
+    
+    ChannelState: string | undefined;
+    
+    CreationTime?: Date;
+    
+    FillerSlate?: SlateSource;
+    
+    LastModifiedTime?: Date;
+    
+    Outputs: ResponseOutputItem[] | undefined;
+    
+    PlaybackMode: string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Channel {
+    
+    const filterSensitiveLog: (obj: Channel) => any;
+}
+export declare enum Mode {
+    BEHIND_LIVE_EDGE = "BEHIND_LIVE_EDGE",
+    OFF = "OFF"
+}
+
+export interface AvailSuppression {
+    
+    Mode?: Mode | string;
+    
+    Value?: string;
+}
+export declare namespace AvailSuppression {
+    
+    const filterSensitiveLog: (obj: AvailSuppression) => any;
+}
+
+export interface Bumper {
+    
+    EndUrl?: string;
+    
+    StartUrl?: string;
+}
+export declare namespace Bumper {
+    
+    const filterSensitiveLog: (obj: Bumper) => any;
+}
+
+export interface CdnConfiguration {
+    
+    AdSegmentUrlPrefix?: string;
+    
+    ContentSegmentUrlPrefix?: string;
+}
+export declare namespace CdnConfiguration {
+    
+    const filterSensitiveLog: (obj: CdnConfiguration) => any;
+}
+export declare enum OriginManifestType {
+    MULTI_PERIOD = "MULTI_PERIOD",
+    SINGLE_PERIOD = "SINGLE_PERIOD"
+}
+
+export interface DashConfiguration {
+    
+    ManifestEndpointPrefix?: string;
+    
+    MpdLocation?: string;
+    
+    OriginManifestType?: OriginManifestType | string;
+}
+export declare namespace DashConfiguration {
+    
+    const filterSensitiveLog: (obj: DashConfiguration) => any;
+}
+
+export interface HlsConfiguration {
+    
+    ManifestEndpointPrefix?: string;
+}
+export declare namespace HlsConfiguration {
+    
+    const filterSensitiveLog: (obj: HlsConfiguration) => any;
+}
+
+export interface LivePreRollConfiguration {
+    
+    AdDecisionServerUrl?: string;
+    
+    MaxDurationSeconds?: number;
+}
+export declare namespace LivePreRollConfiguration {
+    
+    const filterSensitiveLog: (obj: LivePreRollConfiguration) => any;
+}
+
+export interface LogConfiguration {
+    
+    PercentEnabled: number | undefined;
+}
+export declare namespace LogConfiguration {
+    
+    const filterSensitiveLog: (obj: LogConfiguration) => any;
+}
+
+export interface AdMarkerPassthrough {
+    
+    Enabled?: boolean;
+}
+export declare namespace AdMarkerPassthrough {
+    
+    const filterSensitiveLog: (obj: AdMarkerPassthrough) => any;
+}
+
+export interface ManifestProcessingRules {
+    
+    AdMarkerPassthrough?: AdMarkerPassthrough;
+}
+export declare namespace ManifestProcessingRules {
+    
+    const filterSensitiveLog: (obj: ManifestProcessingRules) => any;
+}
+
+export interface PlaybackConfiguration {
+    
+    AdDecisionServerUrl?: string;
+    
+    AvailSuppression?: AvailSuppression;
+    
+    Bumper?: Bumper;
+    
+    CdnConfiguration?: CdnConfiguration;
+    
+    ConfigurationAliases?: {
+        [key: string]: {
+            [key: string]: string;
+        };
+    };
+    
+    DashConfiguration?: DashConfiguration;
+    
+    HlsConfiguration?: HlsConfiguration;
+    
+    LivePreRollConfiguration?: LivePreRollConfiguration;
+    
+    LogConfiguration?: LogConfiguration;
+    
+    ManifestProcessingRules?: ManifestProcessingRules;
+    
+    Name?: string;
+    
+    PersonalizationThresholdSeconds?: number;
+    
+    PlaybackConfigurationArn?: string;
+    
+    PlaybackEndpointPrefix?: string;
+    
+    SessionInitializationEndpointPrefix?: string;
+    
+    SlateAdUrl?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    TranscodeProfileName?: string;
+    
+    VideoContentSourceUrl?: string;
+}
+export declare namespace PlaybackConfiguration {
+    
+    const filterSensitiveLog: (obj: PlaybackConfiguration) => any;
+}
+
+export interface PrefetchConsumption {
+    
+    AvailMatchingCriteria?: AvailMatchingCriteria[];
+    
+    EndTime: Date | undefined;
+    
+    StartTime?: Date;
+}
+export declare namespace PrefetchConsumption {
+    
+    const filterSensitiveLog: (obj: PrefetchConsumption) => any;
+}
+
+export interface PrefetchRetrieval {
+    
+    DynamicVariables?: {
+        [key: string]: string;
+    };
+    
+    EndTime: Date | undefined;
+    
+    StartTime?: Date;
+}
+export declare namespace PrefetchRetrieval {
+    
+    const filterSensitiveLog: (obj: PrefetchRetrieval) => any;
+}
+
+export interface PrefetchSchedule {
+    
+    Arn: string | undefined;
+    
+    Consumption: PrefetchConsumption | undefined;
+    
+    Name: string | undefined;
+    
+    PlaybackConfigurationName: string | undefined;
+    
+    Retrieval: PrefetchRetrieval | undefined;
+    
+    StreamId?: string;
+}
+export declare namespace PrefetchSchedule {
+    
+    const filterSensitiveLog: (obj: PrefetchSchedule) => any;
+}
+
+export interface ScheduleAdBreak {
+    
+    ApproximateDurationSeconds?: number;
+    
+    ApproximateStartTime?: Date;
+    
+    SourceLocationName?: string;
+    
+    VodSourceName?: string;
+}
+export declare namespace ScheduleAdBreak {
+    
+    const filterSensitiveLog: (obj: ScheduleAdBreak) => any;
+}
+export declare enum ScheduleEntryType {
+    FILLER_SLATE = "FILLER_SLATE",
+    PROGRAM = "PROGRAM"
+}
+
+export interface ScheduleEntry {
+    
+    ApproximateDurationSeconds?: number;
+    
+    ApproximateStartTime?: Date;
+    
+    Arn: string | undefined;
+    
+    ChannelName: string | undefined;
+    
+    ProgramName: string | undefined;
+    
+    ScheduleAdBreaks?: ScheduleAdBreak[];
+    
+    ScheduleEntryType?: ScheduleEntryType | string;
+    
+    SourceLocationName: string | undefined;
+    
+    VodSourceName: string | undefined;
+}
+export declare namespace ScheduleEntry {
+    
+    const filterSensitiveLog: (obj: ScheduleEntry) => any;
+}
+export interface SegmentDeliveryConfiguration {
+    BaseUrl?: string;
+    Name?: string;
+}
+export declare namespace SegmentDeliveryConfiguration {
+    
+    const filterSensitiveLog: (obj: SegmentDeliveryConfiguration) => any;
+}
+export declare enum AccessType {
+    S3_SIGV4 = "S3_SIGV4",
+    SECRETS_MANAGER_ACCESS_TOKEN = "SECRETS_MANAGER_ACCESS_TOKEN"
+}
+
+export interface SecretsManagerAccessTokenConfiguration {
+    
+    HeaderName?: string;
+    
+    SecretArn?: string;
+    
+    SecretStringKey?: string;
+}
+export declare namespace SecretsManagerAccessTokenConfiguration {
+    
+    const filterSensitiveLog: (obj: SecretsManagerAccessTokenConfiguration) => any;
+}
+
+export interface AccessConfiguration {
+    
+    AccessType?: AccessType | string;
+    
+    SecretsManagerAccessTokenConfiguration?: SecretsManagerAccessTokenConfiguration;
+}
+export declare namespace AccessConfiguration {
+    
+    const filterSensitiveLog: (obj: AccessConfiguration) => any;
+}
+
+export interface DefaultSegmentDeliveryConfiguration {
+    
+    BaseUrl?: string;
+}
+export declare namespace DefaultSegmentDeliveryConfiguration {
+    
+    const filterSensitiveLog: (obj: DefaultSegmentDeliveryConfiguration) => any;
+}
+
+export interface HttpConfiguration {
+    
+    BaseUrl: string | undefined;
+}
+export declare namespace HttpConfiguration {
+    
+    const filterSensitiveLog: (obj: HttpConfiguration) => any;
+}
+
+export interface SourceLocation {
+    
+    AccessConfiguration?: AccessConfiguration;
+    
+    Arn: string | undefined;
+    
+    CreationTime?: Date;
+    
+    DefaultSegmentDeliveryConfiguration?: DefaultSegmentDeliveryConfiguration;
+    
+    HttpConfiguration: HttpConfiguration | undefined;
+    
+    LastModifiedTime?: Date;
+    SegmentDeliveryConfigurations?: SegmentDeliveryConfiguration[];
+    
+    SourceLocationName: string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace SourceLocation {
+    
+    const filterSensitiveLog: (obj: SourceLocation) => any;
+}
+export declare enum Type {
+    DASH = "DASH",
+    HLS = "HLS"
+}
+
+export interface HttpPackageConfiguration {
+    
+    Path: string | undefined;
+    
+    SourceGroup: string | undefined;
+    
+    Type: Type | string | undefined;
+}
+export declare namespace HttpPackageConfiguration {
+    
+    const filterSensitiveLog: (obj: HttpPackageConfiguration) => any;
+}
+
+export interface VodSource {
+    
+    Arn: string | undefined;
+    
+    CreationTime?: Date;
+    
+    HttpPackageConfigurations: HttpPackageConfiguration[] | undefined;
+    
+    LastModifiedTime?: Date;
+    
+    SourceLocationName: string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    VodSourceName: string | undefined;
+}
+export declare namespace VodSource {
+    
+    const filterSensitiveLog: (obj: VodSource) => any;
+}
+
+export interface BadRequestException extends __SmithyException, $MetadataBearer {
+    name: "BadRequestException";
+    $fault: "client";
+    Message?: string;
+}
+export declare enum ChannelState {
+    RUNNING = "RUNNING",
+    STOPPED = "STOPPED"
+}
+
+export interface ConfigureLogsForPlaybackConfigurationRequest {
+    
+    PercentEnabled: number | undefined;
+    
+    PlaybackConfigurationName: string | undefined;
+}
+export declare namespace ConfigureLogsForPlaybackConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: ConfigureLogsForPlaybackConfigurationRequest) => any;
+}
+export interface ConfigureLogsForPlaybackConfigurationResponse {
+    
+    PercentEnabled?: number;
+    
+    PlaybackConfigurationName?: string;
+}
+export declare namespace ConfigureLogsForPlaybackConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: ConfigureLogsForPlaybackConfigurationResponse) => any;
+}
+
+export interface RequestOutputItem {
+    
+    DashPlaylistSettings?: DashPlaylistSettings;
+    
+    HlsPlaylistSettings?: HlsPlaylistSettings;
+    
+    ManifestName: string | undefined;
+    
+    SourceGroup: string | undefined;
+}
+export declare namespace RequestOutputItem {
+    
+    const filterSensitiveLog: (obj: RequestOutputItem) => any;
+}
+export declare enum PlaybackMode {
+    LINEAR = "LINEAR",
+    LOOP = "LOOP"
+}
+export interface CreateChannelRequest {
+    
+    ChannelName: string | undefined;
+    
+    FillerSlate?: SlateSource;
+    
+    Outputs: RequestOutputItem[] | undefined;
+    
+    PlaybackMode: PlaybackMode | string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateChannelRequest {
+    
+    const filterSensitiveLog: (obj: CreateChannelRequest) => any;
+}
+export interface CreateChannelResponse {
+    
+    Arn?: string;
+    
+    ChannelName?: string;
+    
+    ChannelState?: ChannelState | string;
+    
+    CreationTime?: Date;
+    
+    FillerSlate?: SlateSource;
+    
+    LastModifiedTime?: Date;
+    
+    Outputs?: ResponseOutputItem[];
+    
+    PlaybackMode?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateChannelResponse {
+    
+    const filterSensitiveLog: (obj: CreateChannelResponse) => any;
+}
+export interface CreatePrefetchScheduleRequest {
+    
+    Consumption: PrefetchConsumption | undefined;
+    
+    Name: string | undefined;
+    
+    PlaybackConfigurationName: string | undefined;
+    
+    Retrieval: PrefetchRetrieval | undefined;
+    
+    StreamId?: string;
+}
+export declare namespace CreatePrefetchScheduleRequest {
+    
+    const filterSensitiveLog: (obj: CreatePrefetchScheduleRequest) => any;
+}
+export interface CreatePrefetchScheduleResponse {
+    
+    Arn?: string;
+    
+    Consumption?: PrefetchConsumption;
+    
+    Name?: string;
+    
+    PlaybackConfigurationName?: string;
+    
+    Retrieval?: PrefetchRetrieval;
+    
+    StreamId?: string;
+}
+export declare namespace CreatePrefetchScheduleResponse {
+    
+    const filterSensitiveLog: (obj: CreatePrefetchScheduleResponse) => any;
+}
+export declare enum RelativePosition {
+    AFTER_PROGRAM = "AFTER_PROGRAM",
+    BEFORE_PROGRAM = "BEFORE_PROGRAM"
+}
+
+export interface Transition {
+    
+    RelativePosition: RelativePosition | string | undefined;
+    
+    RelativeProgram?: string;
+    
+    ScheduledStartTimeMillis?: number;
+    
+    Type: string | undefined;
+}
+export declare namespace Transition {
+    
+    const filterSensitiveLog: (obj: Transition) => any;
+}
+
+export interface ScheduleConfiguration {
+    
+    Transition: Transition | undefined;
+}
+export declare namespace ScheduleConfiguration {
+    
+    const filterSensitiveLog: (obj: ScheduleConfiguration) => any;
+}
+export interface CreateProgramRequest {
+    
+    AdBreaks?: AdBreak[];
+    
+    ChannelName: string | undefined;
+    
+    ProgramName: string | undefined;
+    
+    ScheduleConfiguration: ScheduleConfiguration | undefined;
+    
+    SourceLocationName: string | undefined;
+    
+    VodSourceName: string | undefined;
+}
+export declare namespace CreateProgramRequest {
+    
+    const filterSensitiveLog: (obj: CreateProgramRequest) => any;
+}
+export interface CreateProgramResponse {
+    
+    AdBreaks?: AdBreak[];
+    
+    Arn?: string;
+    
+    ChannelName?: string;
+    
+    CreationTime?: Date;
+    
+    ProgramName?: string;
+    
+    ScheduledStartTime?: Date;
+    
+    SourceLocationName?: string;
+    
+    VodSourceName?: string;
+}
+export declare namespace CreateProgramResponse {
+    
+    const filterSensitiveLog: (obj: CreateProgramResponse) => any;
+}
+export interface CreateSourceLocationRequest {
+    
+    AccessConfiguration?: AccessConfiguration;
+    
+    DefaultSegmentDeliveryConfiguration?: DefaultSegmentDeliveryConfiguration;
+    
+    HttpConfiguration: HttpConfiguration | undefined;
+    SegmentDeliveryConfigurations?: SegmentDeliveryConfiguration[];
+    
+    SourceLocationName: string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateSourceLocationRequest {
+    
+    const filterSensitiveLog: (obj: CreateSourceLocationRequest) => any;
+}
+export interface CreateSourceLocationResponse {
+    
+    AccessConfiguration?: AccessConfiguration;
+    
+    Arn?: string;
+    
+    CreationTime?: Date;
+    
+    DefaultSegmentDeliveryConfiguration?: DefaultSegmentDeliveryConfiguration;
+    
+    HttpConfiguration?: HttpConfiguration;
+    
+    LastModifiedTime?: Date;
+    SegmentDeliveryConfigurations?: SegmentDeliveryConfiguration[];
+    
+    SourceLocationName?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateSourceLocationResponse {
+    
+    const filterSensitiveLog: (obj: CreateSourceLocationResponse) => any;
+}
+export interface CreateVodSourceRequest {
+    
+    HttpPackageConfigurations: HttpPackageConfiguration[] | undefined;
+    
+    SourceLocationName: string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    VodSourceName: string | undefined;
+}
+export declare namespace CreateVodSourceRequest {
+    
+    const filterSensitiveLog: (obj: CreateVodSourceRequest) => any;
+}
+export interface CreateVodSourceResponse {
+    
+    Arn?: string;
+    
+    CreationTime?: Date;
+    
+    HttpPackageConfigurations?: HttpPackageConfiguration[];
+    
+    LastModifiedTime?: Date;
+    
+    SourceLocationName?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    VodSourceName?: string;
+}
+export declare namespace CreateVodSourceResponse {
+    
+    const filterSensitiveLog: (obj: CreateVodSourceResponse) => any;
+}
+
+export interface DashConfigurationForPut {
+    
+    MpdLocation?: string;
+    
+    OriginManifestType?: OriginManifestType | string;
+}
+export declare namespace DashConfigurationForPut {
+    
+    const filterSensitiveLog: (obj: DashConfigurationForPut) => any;
+}
+export interface DeleteChannelRequest {
+    
+    ChannelName: string | undefined;
+}
+export declare namespace DeleteChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteChannelRequest) => any;
+}
+export interface DeleteChannelResponse {
+}
+export declare namespace DeleteChannelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteChannelResponse) => any;
+}
+export interface DeleteChannelPolicyRequest {
+    
+    ChannelName: string | undefined;
+}
+export declare namespace DeleteChannelPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteChannelPolicyRequest) => any;
+}
+export interface DeleteChannelPolicyResponse {
+}
+export declare namespace DeleteChannelPolicyResponse {
+    
+    const filterSensitiveLog: (obj: DeleteChannelPolicyResponse) => any;
+}
+export interface DeletePlaybackConfigurationRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeletePlaybackConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeletePlaybackConfigurationRequest) => any;
+}
+export interface DeletePlaybackConfigurationResponse {
+}
+export declare namespace DeletePlaybackConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DeletePlaybackConfigurationResponse) => any;
+}
+export interface DeletePrefetchScheduleRequest {
+    
+    Name: string | undefined;
+    
+    PlaybackConfigurationName: string | undefined;
+}
+export declare namespace DeletePrefetchScheduleRequest {
+    
+    const filterSensitiveLog: (obj: DeletePrefetchScheduleRequest) => any;
+}
+export interface DeletePrefetchScheduleResponse {
+}
+export declare namespace DeletePrefetchScheduleResponse {
+    
+    const filterSensitiveLog: (obj: DeletePrefetchScheduleResponse) => any;
+}
+export interface DeleteProgramRequest {
+    
+    ChannelName: string | undefined;
+    
+    ProgramName: string | undefined;
+}
+export declare namespace DeleteProgramRequest {
+    
+    const filterSensitiveLog: (obj: DeleteProgramRequest) => any;
+}
+export interface DeleteProgramResponse {
+}
+export declare namespace DeleteProgramResponse {
+    
+    const filterSensitiveLog: (obj: DeleteProgramResponse) => any;
+}
+export interface DeleteSourceLocationRequest {
+    
+    SourceLocationName: string | undefined;
+}
+export declare namespace DeleteSourceLocationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSourceLocationRequest) => any;
+}
+export interface DeleteSourceLocationResponse {
+}
+export declare namespace DeleteSourceLocationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSourceLocationResponse) => any;
+}
+export interface DeleteVodSourceRequest {
+    
+    SourceLocationName: string | undefined;
+    
+    VodSourceName: string | undefined;
+}
+export declare namespace DeleteVodSourceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVodSourceRequest) => any;
+}
+export interface DeleteVodSourceResponse {
+}
+export declare namespace DeleteVodSourceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteVodSourceResponse) => any;
+}
+export interface DescribeChannelRequest {
+    
+    ChannelName: string | undefined;
+}
+export declare namespace DescribeChannelRequest {
+    
+    const filterSensitiveLog: (obj: DescribeChannelRequest) => any;
+}
+export interface DescribeChannelResponse {
+    
+    Arn?: string;
+    
+    ChannelName?: string;
+    
+    ChannelState?: ChannelState | string;
+    
+    CreationTime?: Date;
+    
+    FillerSlate?: SlateSource;
+    
+    LastModifiedTime?: Date;
+    
+    Outputs?: ResponseOutputItem[];
+    
+    PlaybackMode?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace DescribeChannelResponse {
+    
+    const filterSensitiveLog: (obj: DescribeChannelResponse) => any;
+}
+export interface DescribeProgramRequest {
+    
+    ChannelName: string | undefined;
+    
+    ProgramName: string | undefined;
+}
+export declare namespace DescribeProgramRequest {
+    
+    const filterSensitiveLog: (obj: DescribeProgramRequest) => any;
+}
+export interface DescribeProgramResponse {
+    
+    AdBreaks?: AdBreak[];
+    
+    Arn?: string;
+    
+    ChannelName?: string;
+    
+    CreationTime?: Date;
+    
+    ProgramName?: string;
+    
+    ScheduledStartTime?: Date;
+    
+    SourceLocationName?: string;
+    
+    VodSourceName?: string;
+}
+export declare namespace DescribeProgramResponse {
+    
+    const filterSensitiveLog: (obj: DescribeProgramResponse) => any;
+}
+export interface DescribeSourceLocationRequest {
+    
+    SourceLocationName: string | undefined;
+}
+export declare namespace DescribeSourceLocationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeSourceLocationRequest) => any;
+}
+export interface DescribeSourceLocationResponse {
+    
+    AccessConfiguration?: AccessConfiguration;
+    
+    Arn?: string;
+    
+    CreationTime?: Date;
+    
+    DefaultSegmentDeliveryConfiguration?: DefaultSegmentDeliveryConfiguration;
+    
+    HttpConfiguration?: HttpConfiguration;
+    
+    LastModifiedTime?: Date;
+    SegmentDeliveryConfigurations?: SegmentDeliveryConfiguration[];
+    
+    SourceLocationName?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace DescribeSourceLocationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeSourceLocationResponse) => any;
+}
+export interface DescribeVodSourceRequest {
+    
+    SourceLocationName: string | undefined;
+    
+    VodSourceName: string | undefined;
+}
+export declare namespace DescribeVodSourceRequest {
+    
+    const filterSensitiveLog: (obj: DescribeVodSourceRequest) => any;
+}
+export interface DescribeVodSourceResponse {
+    
+    Arn?: string;
+    
+    CreationTime?: Date;
+    
+    HttpPackageConfigurations?: HttpPackageConfiguration[];
+    
+    LastModifiedTime?: Date;
+    
+    SourceLocationName?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    VodSourceName?: string;
+}
+export declare namespace DescribeVodSourceResponse {
+    
+    const filterSensitiveLog: (obj: DescribeVodSourceResponse) => any;
+}
+export interface GetChannelPolicyRequest {
+    
+    ChannelName: string | undefined;
+}
+export declare namespace GetChannelPolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetChannelPolicyRequest) => any;
+}
+export interface GetChannelPolicyResponse {
+    
+    Policy?: string;
+}
+export declare namespace GetChannelPolicyResponse {
+    
+    const filterSensitiveLog: (obj: GetChannelPolicyResponse) => any;
+}
+export interface GetChannelScheduleRequest {
+    
+    ChannelName: string | undefined;
+    
+    DurationMinutes?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetChannelScheduleRequest {
+    
+    const filterSensitiveLog: (obj: GetChannelScheduleRequest) => any;
+}
+export interface GetChannelScheduleResponse {
+    
+    Items?: ScheduleEntry[];
+    
+    NextToken?: string;
+}
+export declare namespace GetChannelScheduleResponse {
+    
+    const filterSensitiveLog: (obj: GetChannelScheduleResponse) => any;
+}
+export interface GetPlaybackConfigurationRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace GetPlaybackConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetPlaybackConfigurationRequest) => any;
+}
+export interface GetPlaybackConfigurationResponse {
+    
+    AdDecisionServerUrl?: string;
+    
+    AvailSuppression?: AvailSuppression;
+    
+    Bumper?: Bumper;
+    
+    CdnConfiguration?: CdnConfiguration;
+    
+    ConfigurationAliases?: {
+        [key: string]: {
+            [key: string]: string;
+        };
+    };
+    
+    DashConfiguration?: DashConfiguration;
+    
+    HlsConfiguration?: HlsConfiguration;
+    
+    LivePreRollConfiguration?: LivePreRollConfiguration;
+    
+    LogConfiguration?: LogConfiguration;
+    
+    ManifestProcessingRules?: ManifestProcessingRules;
+    
+    Name?: string;
+    
+    PersonalizationThresholdSeconds?: number;
+    
+    PlaybackConfigurationArn?: string;
+    
+    PlaybackEndpointPrefix?: string;
+    
+    SessionInitializationEndpointPrefix?: string;
+    
+    SlateAdUrl?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    TranscodeProfileName?: string;
+    
+    VideoContentSourceUrl?: string;
+}
+export declare namespace GetPlaybackConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetPlaybackConfigurationResponse) => any;
+}
+export interface GetPrefetchScheduleRequest {
+    
+    Name: string | undefined;
+    
+    PlaybackConfigurationName: string | undefined;
+}
+export declare namespace GetPrefetchScheduleRequest {
+    
+    const filterSensitiveLog: (obj: GetPrefetchScheduleRequest) => any;
+}
+export interface GetPrefetchScheduleResponse {
+    
+    Arn?: string;
+    
+    Consumption?: PrefetchConsumption;
+    
+    Name?: string;
+    
+    PlaybackConfigurationName?: string;
+    
+    Retrieval?: PrefetchRetrieval;
+    
+    StreamId?: string;
+}
+export declare namespace GetPrefetchScheduleResponse {
+    
+    const filterSensitiveLog: (obj: GetPrefetchScheduleResponse) => any;
+}
+export interface ListAlertsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListAlertsRequest {
+    
+    const filterSensitiveLog: (obj: ListAlertsRequest) => any;
+}
+export interface ListAlertsResponse {
+    
+    Items?: Alert[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAlertsResponse {
+    
+    const filterSensitiveLog: (obj: ListAlertsResponse) => any;
+}
+export interface ListChannelsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListChannelsRequest {
+    
+    const filterSensitiveLog: (obj: ListChannelsRequest) => any;
+}
+export interface ListChannelsResponse {
+    
+    Items?: Channel[];
+    
+    NextToken?: string;
+}
+export declare namespace ListChannelsResponse {
+    
+    const filterSensitiveLog: (obj: ListChannelsResponse) => any;
+}
+export interface ListPlaybackConfigurationsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListPlaybackConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: ListPlaybackConfigurationsRequest) => any;
+}
+export interface ListPlaybackConfigurationsResponse {
+    
+    Items?: PlaybackConfiguration[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPlaybackConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: ListPlaybackConfigurationsResponse) => any;
+}
+export interface ListPrefetchSchedulesRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    PlaybackConfigurationName: string | undefined;
+    
+    StreamId?: string;
+}
+export declare namespace ListPrefetchSchedulesRequest {
+    
+    const filterSensitiveLog: (obj: ListPrefetchSchedulesRequest) => any;
+}
+export interface ListPrefetchSchedulesResponse {
+    
+    Items?: PrefetchSchedule[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPrefetchSchedulesResponse {
+    
+    const filterSensitiveLog: (obj: ListPrefetchSchedulesResponse) => any;
+}
+export interface ListSourceLocationsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListSourceLocationsRequest {
+    
+    const filterSensitiveLog: (obj: ListSourceLocationsRequest) => any;
+}
+export interface ListSourceLocationsResponse {
+    
+    Items?: SourceLocation[];
+    
+    NextToken?: string;
+}
+export declare namespace ListSourceLocationsResponse {
+    
+    const filterSensitiveLog: (obj: ListSourceLocationsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListVodSourcesRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    SourceLocationName: string | undefined;
+}
+export declare namespace ListVodSourcesRequest {
+    
+    const filterSensitiveLog: (obj: ListVodSourcesRequest) => any;
+}
+export interface ListVodSourcesResponse {
+    
+    Items?: VodSource[];
+    
+    NextToken?: string;
+}
+export declare namespace ListVodSourcesResponse {
+    
+    const filterSensitiveLog: (obj: ListVodSourcesResponse) => any;
+}
+export interface PutChannelPolicyRequest {
+    
+    ChannelName: string | undefined;
+    
+    Policy: string | undefined;
+}
+export declare namespace PutChannelPolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutChannelPolicyRequest) => any;
+}
+export interface PutChannelPolicyResponse {
+}
+export declare namespace PutChannelPolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutChannelPolicyResponse) => any;
+}
+export interface PutPlaybackConfigurationRequest {
+    
+    AdDecisionServerUrl?: string;
+    
+    AvailSuppression?: AvailSuppression;
+    
+    Bumper?: Bumper;
+    
+    CdnConfiguration?: CdnConfiguration;
+    
+    ConfigurationAliases?: {
+        [key: string]: {
+            [key: string]: string;
+        };
+    };
+    
+    DashConfiguration?: DashConfigurationForPut;
+    
+    LivePreRollConfiguration?: LivePreRollConfiguration;
+    
+    ManifestProcessingRules?: ManifestProcessingRules;
+    
+    Name?: string;
+    
+    PersonalizationThresholdSeconds?: number;
+    
+    SlateAdUrl?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    TranscodeProfileName?: string;
+    
+    VideoContentSourceUrl?: string;
+}
+export declare namespace PutPlaybackConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: PutPlaybackConfigurationRequest) => any;
+}
+export interface PutPlaybackConfigurationResponse {
+    
+    AdDecisionServerUrl?: string;
+    
+    AvailSuppression?: AvailSuppression;
+    
+    Bumper?: Bumper;
+    
+    CdnConfiguration?: CdnConfiguration;
+    
+    ConfigurationAliases?: {
+        [key: string]: {
+            [key: string]: string;
+        };
+    };
+    
+    DashConfiguration?: DashConfiguration;
+    
+    HlsConfiguration?: HlsConfiguration;
+    
+    LivePreRollConfiguration?: LivePreRollConfiguration;
+    
+    LogConfiguration?: LogConfiguration;
+    
+    ManifestProcessingRules?: ManifestProcessingRules;
+    
+    Name?: string;
+    
+    PersonalizationThresholdSeconds?: number;
+    
+    PlaybackConfigurationArn?: string;
+    
+    PlaybackEndpointPrefix?: string;
+    
+    SessionInitializationEndpointPrefix?: string;
+    
+    SlateAdUrl?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    TranscodeProfileName?: string;
+    
+    VideoContentSourceUrl?: string;
+}
+export declare namespace PutPlaybackConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: PutPlaybackConfigurationResponse) => any;
+}
+export interface StartChannelRequest {
+    
+    ChannelName: string | undefined;
+}
+export declare namespace StartChannelRequest {
+    
+    const filterSensitiveLog: (obj: StartChannelRequest) => any;
+}
+export interface StartChannelResponse {
+}
+export declare namespace StartChannelResponse {
+    
+    const filterSensitiveLog: (obj: StartChannelResponse) => any;
+}
+export interface StopChannelRequest {
+    
+    ChannelName: string | undefined;
+}
+export declare namespace StopChannelRequest {
+    
+    const filterSensitiveLog: (obj: StopChannelRequest) => any;
+}
+export interface StopChannelResponse {
+}
+export declare namespace StopChannelResponse {
+    
+    const filterSensitiveLog: (obj: StopChannelResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UpdateChannelRequest {
+    
+    ChannelName: string | undefined;
+    
+    FillerSlate?: SlateSource;
+    
+    Outputs: RequestOutputItem[] | undefined;
+}
+export declare namespace UpdateChannelRequest {
+    
+    const filterSensitiveLog: (obj: UpdateChannelRequest) => any;
+}
+export interface UpdateChannelResponse {
+    
+    Arn?: string;
+    
+    ChannelName?: string;
+    
+    ChannelState?: ChannelState | string;
+    
+    CreationTime?: Date;
+    
+    FillerSlate?: SlateSource;
+    
+    LastModifiedTime?: Date;
+    
+    Outputs?: ResponseOutputItem[];
+    
+    PlaybackMode?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace UpdateChannelResponse {
+    
+    const filterSensitiveLog: (obj: UpdateChannelResponse) => any;
+}
+export interface UpdateSourceLocationRequest {
+    
+    AccessConfiguration?: AccessConfiguration;
+    
+    DefaultSegmentDeliveryConfiguration?: DefaultSegmentDeliveryConfiguration;
+    
+    HttpConfiguration: HttpConfiguration | undefined;
+    SegmentDeliveryConfigurations?: SegmentDeliveryConfiguration[];
+    
+    SourceLocationName: string | undefined;
+}
+export declare namespace UpdateSourceLocationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateSourceLocationRequest) => any;
+}
+export interface UpdateSourceLocationResponse {
+    
+    AccessConfiguration?: AccessConfiguration;
+    
+    Arn?: string;
+    
+    CreationTime?: Date;
+    
+    DefaultSegmentDeliveryConfiguration?: DefaultSegmentDeliveryConfiguration;
+    
+    HttpConfiguration?: HttpConfiguration;
+    
+    LastModifiedTime?: Date;
+    SegmentDeliveryConfigurations?: SegmentDeliveryConfiguration[];
+    
+    SourceLocationName?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace UpdateSourceLocationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateSourceLocationResponse) => any;
+}
+export interface UpdateVodSourceRequest {
+    
+    HttpPackageConfigurations: HttpPackageConfiguration[] | undefined;
+    
+    SourceLocationName: string | undefined;
+    
+    VodSourceName: string | undefined;
+}
+export declare namespace UpdateVodSourceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateVodSourceRequest) => any;
+}
+export interface UpdateVodSourceResponse {
+    
+    Arn?: string;
+    
+    CreationTime?: Date;
+    
+    HttpPackageConfigurations?: HttpPackageConfiguration[];
+    
+    LastModifiedTime?: Date;
+    
+    SourceLocationName?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    VodSourceName?: string;
+}
+export declare namespace UpdateVodSourceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateVodSourceResponse) => any;
+}