@aws-cdk/aws-medialive-alpha 2.268.0-alpha.0

package/lib/input-attachment.d.ts

@@ -0,0 +1,319 @@
+import type { Bitrate, Duration } from 'aws-cdk-lib';
+import type { AudioSelector } from './audio-selector';
+import type { CaptionSelector } from './caption-selector';
+import type { IInput } from './input';
+import type { VideoSelectorSettings } from './video-selection';
+/**
+ * The source end behavior for file-based inputs.
+ */
+export declare class SourceEndBehavior {
+    /** Continue with the last frame */
+    static readonly CONTINUE: SourceEndBehavior;
+    /** Loop the input */
+    static readonly LOOP: SourceEndBehavior;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): SourceEndBehavior;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/**
+ * Input filter mode.
+ */
+export declare class InputFilter {
+    /** Auto-detect filtering based on input type */
+    static readonly AUTO: InputFilter;
+    /** Disable filtering */
+    static readonly DISABLED: InputFilter;
+    /** Force filtering regardless of input type */
+    static readonly FORCED: InputFilter;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): InputFilter;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/**
+ * SMPTE-2038 data preference.
+ */
+export declare class Smpte2038DataPreference {
+    /** Extract from SMPTE-2038 if present */
+    static readonly PREFER: Smpte2038DataPreference;
+    /** Never extract from SMPTE-2038 */
+    static readonly IGNORE: Smpte2038DataPreference;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): Smpte2038DataPreference;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/**
+ * Server validation mode for HTTPS inputs.
+ */
+export declare class ServerValidation {
+    /** Check cryptography and server name */
+    static readonly CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME: ServerValidation;
+    /** Check cryptography only (useful for S3 bucket names with dots) */
+    static readonly CHECK_CRYPTOGRAPHY_ONLY: ServerValidation;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): ServerValidation;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/**
+ * Network input settings for URL pull inputs.
+ */
+export interface NetworkInputSettings {
+    /**
+     * HTTPS server certificate validation mode.
+     * @default - service default
+     */
+    readonly serverValidation?: ServerValidation;
+    /**
+     * HLS input settings (bandwidth selection, buffer segments, retries).
+     * @default - no HLS input settings
+     */
+    readonly hlsInputSettings?: HlsInputSettings;
+    /**
+     * For a multicast input, filter to content from a specific source IP address
+     * (source-specific multicast).
+     * @default - no source IP filter
+     */
+    readonly multicastSourceIp?: string;
+}
+/** The source MediaLive ingests SCTE-35 messages from for an HLS input. */
+export declare class HlsScte35Source {
+    /** Ingest SCTE-35 from the content segments (in the stream). */
+    static readonly SEGMENTS: HlsScte35Source;
+    /** Ingest SCTE-35 from tags in the playlist (the HLS manifest). */
+    static readonly MANIFEST: HlsScte35Source;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): HlsScte35Source;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/**
+ * HLS input settings for URL pull inputs.
+ */
+export interface HlsInputSettings {
+    /**
+     * The bandwidth to select from the HLS manifest. MediaLive chooses the rendition
+     * whose manifest bandwidth most closely matches this value.
+     * @default - highest bandwidth
+     */
+    readonly bandwidth?: Bitrate;
+    /**
+     * When specified, reading of the HLS input begins this many buffer segments from the end
+     * (most recently written segment).
+     * @default - the HLS input begins with the first segment specified in the m3u8
+     */
+    readonly bufferSegments?: number;
+    /**
+     * Number of consecutive read failures before the input is considered unavailable.
+     * @default - service default
+     */
+    readonly retries?: number;
+    /**
+     * The interval between retry attempts.
+     * @default - service default
+     */
+    readonly retryInterval?: Duration;
+    /**
+     * The source MediaLive ingests SCTE-35 messages from — the content segments or the manifest.
+     * @default - service default
+     */
+    readonly scte35Source?: HlsScte35Source;
+}
+/**
+ * Input preference when deciding which input to make active after a previously failed input
+ * has recovered.
+ */
+export declare class InputPreference {
+    /** No preference — stay on the currently active input even after the other recovers. */
+    static readonly EQUAL_INPUT_PREFERENCE: InputPreference;
+    /**
+     * Prefer the primary input — switch back to it once it has been free of failover
+     * conditions for the error-clear time.
+     */
+    static readonly PRIMARY_INPUT_PREFERRED: InputPreference;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): InputPreference;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/**
+ * Properties for an input-loss failover condition.
+ */
+export interface InputLossFailoverProps {
+    /**
+     * The amount of time with no input detected before failover occurs.
+     * @default - MediaLive service default
+     */
+    readonly threshold?: Duration;
+}
+/**
+ * Properties for an audio-silence failover condition.
+ */
+export interface AudioSilenceFailoverProps {
+    /**
+     * The audio selector (defined on the input attachment) that MediaLive monitors for
+     * silence. Pass the same `AudioSelector` instance you put in the attachment's
+     * `audioSelectors` — select your most important rendition.
+     */
+    readonly audioSelector: AudioSelector;
+    /**
+     * How long the audio must be silent (audio loss, or quieter than -50 dBFS) before
+     * failover occurs.
+     * @default - MediaLive service default
+     */
+    readonly threshold?: Duration;
+}
+/**
+ * Properties for a video-black failover condition.
+ */
+export interface VideoBlackFailoverProps {
+    /**
+     * The fraction of white (0.0–1.0) below which a pixel is considered black. Every pixel in
+     * a frame must be below this threshold for the frame to count as black. For example, 0.1
+     * means 10% white (90% black).
+     * @default - MediaLive service default
+     */
+    readonly blackDetectThreshold?: number;
+    /**
+     * How long the content must be black before failover occurs.
+     * @default - MediaLive service default
+     */
+    readonly threshold?: Duration;
+}
+/**
+ * A condition that, when met on the active input, triggers automatic input failover to the
+ * secondary input. Create conditions with the static factory methods.
+ */
+export declare abstract class FailoverCondition {
+    /** Fail over when no input is detected for the threshold period. */
+    static inputLoss(props?: InputLossFailoverProps): FailoverCondition;
+    /** Fail over when the monitored audio selector is silent for the threshold period. */
+    static audioSilence(props: AudioSilenceFailoverProps): FailoverCondition;
+    /** Fail over when the content is black for the threshold period. */
+    static videoBlack(props?: VideoBlackFailoverProps): FailoverCondition;
+}
+/**
+ * Automatic input failover configuration for an input attachment. When the active (primary)
+ * input meets any of the failover conditions, MediaLive switches to the secondary input
+ * without restarting the channel. This is input-source redundancy, distinct from the
+ * pipeline redundancy provided by `ChannelClass.STANDARD`.
+ *
+ * @see https://docs.aws.amazon.com/medialive/latest/ug/feature-automatic-input-failover.html
+ */
+export interface AutomaticInputFailover {
+    /**
+     * The secondary input to fail over to. Must be the same input class as the primary input.
+     *
+     * [disable-awslint:prefer-ref-interface]
+     */
+    readonly secondaryInput: IInput;
+    /**
+     * The conditions that trigger failover to the secondary input.
+     * @default - a single input-loss condition with the MediaLive service default threshold
+     */
+    readonly failoverConditions?: FailoverCondition[];
+    /**
+     * Which input to prefer once a failed input has recovered.
+     * @default - EQUAL_INPUT_PREFERENCE, applied by MediaLive
+     */
+    readonly inputPreference?: InputPreference;
+    /**
+     * How long a recovered input must remain free of failover conditions before it is
+     * considered healthy. Particularly relevant with `InputPreference.PRIMARY_INPUT_PREFERRED`.
+     * @default - MediaLive service default
+     */
+    readonly errorClearTime?: Duration;
+}
+/**
+ * An input attachment definition for a channel.
+ */
+export interface InputAttachment {
+    /**
+     * The input to attach.
+     *
+     * [disable-awslint:prefer-ref-interface]
+     */
+    readonly input: IInput;
+    /**
+     * A name for this input attachment, used to reference it in schedule actions.
+     * @default - auto-generated
+     */
+    readonly inputAttachmentName?: string;
+    /**
+     * The source end behavior for file-based inputs.
+     * @default SourceEndBehavior.LOOP for MP4 and TS file inputs, SourceEndBehavior.CONTINUE for all others
+     */
+    readonly sourceEndBehavior?: SourceEndBehavior;
+    /**
+     * The input filter mode.
+     * @default InputFilter.AUTO
+     */
+    readonly inputFilter?: InputFilter;
+    /**
+     * The filter strength (1-5). 1 is minimal, 5 is strongest.
+     * @default 1
+     */
+    readonly filterStrength?: number;
+    /**
+     * Whether to enable the deblock filter.
+     * @default false
+     */
+    readonly deblockFilter?: boolean;
+    /**
+     * Whether to enable the denoise filter.
+     * @default false
+     */
+    readonly denoiseFilter?: boolean;
+    /**
+     * SMPTE-2038 ancillary data preference.
+     * @default Smpte2038DataPreference.IGNORE
+     */
+    readonly smpte2038DataPreference?: Smpte2038DataPreference;
+    /**
+     * Audio selectors to extract specific audio tracks from the input.
+     * @default - no audio selectors (uses default audio)
+     */
+    readonly audioSelectors?: AudioSelector[];
+    /**
+     * Caption selectors to extract specific caption tracks from the input.
+     * @default - no caption selectors
+     */
+    readonly captionSelectors?: CaptionSelector[];
+    /**
+     * The SCTE-35 PID override for this input.
+     * @default - auto-detect
+     */
+    readonly scte35Pid?: number;
+    /**
+     * Video selector settings for the input (color space, PID selection).
+     * @default - no video selector (use default video)
+     */
+    readonly videoSelector?: VideoSelectorSettings;
+    /**
+     * Network input settings (for URL pull inputs — HLS buffer, server validation).
+     * @default - no network input settings
+     */
+    readonly networkInputSettings?: NetworkInputSettings;
+    /**
+     * The logical interface names (MediaLive Anywhere) this input is wired to. Each name maps the
+     * input to a network interface on the channel's nodes.
+     * @default - no logical interface names
+     */
+    readonly logicalInterfaceNames?: string[];
+    /**
+     * Automatic input failover to a secondary input. When the active input meets any of the
+     * failover conditions, MediaLive switches to the secondary input without restarting the
+     * channel. This is input-source redundancy, distinct from the pipeline redundancy of
+     * `ChannelClass.STANDARD`.
+     * @default - no automatic input failover
+     */
+    readonly automaticInputFailover?: AutomaticInputFailover;
+}

package/lib/input-attachment.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailoverCondition = exports.InputPreference = exports.HlsScte35Source = exports.ServerValidation = exports.Smpte2038DataPreference = exports.InputFilter = exports.SourceEndBehavior = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * The source end behavior for file-based inputs.
+ */
+class SourceEndBehavior {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.SourceEndBehavior", version: "2.268.0-alpha.0" };
+    /** Continue with the last frame */
+    static CONTINUE = new SourceEndBehavior('CONTINUE');
+    /** Loop the input */
+    static LOOP = new SourceEndBehavior('LOOP');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new SourceEndBehavior(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.SourceEndBehavior = SourceEndBehavior;
+/**
+ * Input filter mode.
+ */
+class InputFilter {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.InputFilter", version: "2.268.0-alpha.0" };
+    /** Auto-detect filtering based on input type */
+    static AUTO = new InputFilter('AUTO');
+    /** Disable filtering */
+    static DISABLED = new InputFilter('DISABLED');
+    /** Force filtering regardless of input type */
+    static FORCED = new InputFilter('FORCED');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new InputFilter(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.InputFilter = InputFilter;
+/**
+ * SMPTE-2038 data preference.
+ */
+class Smpte2038DataPreference {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.Smpte2038DataPreference", version: "2.268.0-alpha.0" };
+    /** Extract from SMPTE-2038 if present */
+    static PREFER = new Smpte2038DataPreference('PREFER');
+    /** Never extract from SMPTE-2038 */
+    static IGNORE = new Smpte2038DataPreference('IGNORE');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new Smpte2038DataPreference(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.Smpte2038DataPreference = Smpte2038DataPreference;
+/**
+ * Server validation mode for HTTPS inputs.
+ */
+class ServerValidation {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.ServerValidation", version: "2.268.0-alpha.0" };
+    /** Check cryptography and server name */
+    static CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME = new ServerValidation('CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME');
+    /** Check cryptography only (useful for S3 bucket names with dots) */
+    static CHECK_CRYPTOGRAPHY_ONLY = new ServerValidation('CHECK_CRYPTOGRAPHY_ONLY');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new ServerValidation(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.ServerValidation = ServerValidation;
+/** The source MediaLive ingests SCTE-35 messages from for an HLS input. */
+class HlsScte35Source {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.HlsScte35Source", version: "2.268.0-alpha.0" };
+    /** Ingest SCTE-35 from the content segments (in the stream). */
+    static SEGMENTS = new HlsScte35Source('SEGMENTS');
+    /** Ingest SCTE-35 from tags in the playlist (the HLS manifest). */
+    static MANIFEST = new HlsScte35Source('MANIFEST');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new HlsScte35Source(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.HlsScte35Source = HlsScte35Source;
+/**
+ * Input preference when deciding which input to make active after a previously failed input
+ * has recovered.
+ */
+class InputPreference {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.InputPreference", version: "2.268.0-alpha.0" };
+    /** No preference — stay on the currently active input even after the other recovers. */
+    static EQUAL_INPUT_PREFERENCE = new InputPreference('EQUAL_INPUT_PREFERENCE');
+    /**
+     * Prefer the primary input — switch back to it once it has been free of failover
+     * conditions for the error-clear time.
+     */
+    static PRIMARY_INPUT_PREFERRED = new InputPreference('PRIMARY_INPUT_PREFERRED');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new InputPreference(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.InputPreference = InputPreference;
+/**
+ * A condition that, when met on the active input, triggers automatic input failover to the
+ * secondary input. Create conditions with the static factory methods.
+ */
+class FailoverCondition {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.FailoverCondition", version: "2.268.0-alpha.0" };
+    /** Fail over when no input is detected for the threshold period. */
+    static inputLoss(props = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_InputLossFailoverProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.inputLoss);
+            }
+            throw error;
+        }
+        return new InputLossFailoverCondition(props);
+    }
+    /** Fail over when the monitored audio selector is silent for the threshold period. */
+    static audioSilence(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_AudioSilenceFailoverProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.audioSilence);
+            }
+            throw error;
+        }
+        return new AudioSilenceFailoverCondition(props);
+    }
+    /** Fail over when the content is black for the threshold period. */
+    static videoBlack(props = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_VideoBlackFailoverProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.videoBlack);
+            }
+            throw error;
+        }
+        return new VideoBlackFailoverCondition(props);
+    }
+}
+exports.FailoverCondition = FailoverCondition;
+/** @internal */
+class InputLossFailoverCondition extends FailoverCondition {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    _bind() {
+        return {
+            failoverConditionSettings: {
+                inputLossSettings: { inputLossThresholdMsec: this.props.threshold?.toMilliseconds() },
+            },
+        };
+    }
+}
+/** @internal */
+class AudioSilenceFailoverCondition extends FailoverCondition {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    _bind() {
+        return {
+            failoverConditionSettings: {
+                audioSilenceSettings: {
+                    audioSelectorName: this.props.audioSelector.name,
+                    audioSilenceThresholdMsec: this.props.threshold?.toMilliseconds(),
+                },
+            },
+        };
+    }
+}
+/** @internal */
+class VideoBlackFailoverCondition extends FailoverCondition {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    _bind() {
+        return {
+            failoverConditionSettings: {
+                videoBlackSettings: {
+                    blackDetectThreshold: this.props.blackDetectThreshold,
+                    videoBlackThresholdMsec: this.props.threshold?.toMilliseconds(),
+                },
+            },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-attachment.js","sourceRoot":"","sources":["input-attachment.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Bitrate, Duration } from 'aws-cdk-lib';\nimport type { CfnChannel } from 'aws-cdk-lib/aws-medialive';\nimport type { AudioSelector } from './audio-selector';\nimport type { CaptionSelector } from './caption-selector';\nimport type { IInput } from './input';\nimport type { VideoSelectorSettings } from './video-selection';\n\n/**\n * The source end behavior for file-based inputs.\n */\nexport class SourceEndBehavior {\n  /** Continue with the last frame */\n  public static readonly CONTINUE = new SourceEndBehavior('CONTINUE');\n  /** Loop the input */\n  public static readonly LOOP = new SourceEndBehavior('LOOP');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): SourceEndBehavior {\n    return new SourceEndBehavior(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/**\n * Input filter mode.\n */\nexport class InputFilter {\n  /** Auto-detect filtering based on input type */\n  public static readonly AUTO = new InputFilter('AUTO');\n  /** Disable filtering */\n  public static readonly DISABLED = new InputFilter('DISABLED');\n  /** Force filtering regardless of input type */\n  public static readonly FORCED = new InputFilter('FORCED');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): InputFilter {\n    return new InputFilter(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/**\n * SMPTE-2038 data preference.\n */\nexport class Smpte2038DataPreference {\n  /** Extract from SMPTE-2038 if present */\n  public static readonly PREFER = new Smpte2038DataPreference('PREFER');\n  /** Never extract from SMPTE-2038 */\n  public static readonly IGNORE = new Smpte2038DataPreference('IGNORE');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): Smpte2038DataPreference {\n    return new Smpte2038DataPreference(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/**\n * Server validation mode for HTTPS inputs.\n */\nexport class ServerValidation {\n  /** Check cryptography and server name */\n  public static readonly CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME = new ServerValidation('CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME');\n  /** Check cryptography only (useful for S3 bucket names with dots) */\n  public static readonly CHECK_CRYPTOGRAPHY_ONLY = new ServerValidation('CHECK_CRYPTOGRAPHY_ONLY');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): ServerValidation {\n    return new ServerValidation(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/**\n * Network input settings for URL pull inputs.\n */\nexport interface NetworkInputSettings {\n  /**\n   * HTTPS server certificate validation mode.\n   * @default - service default\n   */\n  readonly serverValidation?: ServerValidation;\n  /**\n   * HLS input settings (bandwidth selection, buffer segments, retries).\n   * @default - no HLS input settings\n   */\n  readonly hlsInputSettings?: HlsInputSettings;\n  /**\n   * For a multicast input, filter to content from a specific source IP address\n   * (source-specific multicast).\n   * @default - no source IP filter\n   */\n  readonly multicastSourceIp?: string;\n}\n\n/** The source MediaLive ingests SCTE-35 messages from for an HLS input. */\nexport class HlsScte35Source {\n  /** Ingest SCTE-35 from the content segments (in the stream). */\n  public static readonly SEGMENTS = new HlsScte35Source('SEGMENTS');\n  /** Ingest SCTE-35 from tags in the playlist (the HLS manifest). */\n  public static readonly MANIFEST = new HlsScte35Source('MANIFEST');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): HlsScte35Source {\n    return new HlsScte35Source(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/**\n * HLS input settings for URL pull inputs.\n */\nexport interface HlsInputSettings {\n  /**\n   * The bandwidth to select from the HLS manifest. MediaLive chooses the rendition\n   * whose manifest bandwidth most closely matches this value.\n   * @default - highest bandwidth\n   */\n  readonly bandwidth?: Bitrate;\n  /**\n   * When specified, reading of the HLS input begins this many buffer segments from the end\n   * (most recently written segment).\n   * @default - the HLS input begins with the first segment specified in the m3u8\n   */\n  readonly bufferSegments?: number;\n  /**\n   * Number of consecutive read failures before the input is considered unavailable.\n   * @default - service default\n   */\n  readonly retries?: number;\n  /**\n   * The interval between retry attempts.\n   * @default - service default\n   */\n  readonly retryInterval?: Duration;\n  /**\n   * The source MediaLive ingests SCTE-35 messages from — the content segments or the manifest.\n   * @default - service default\n   */\n  readonly scte35Source?: HlsScte35Source;\n}\n\n/**\n * Input preference when deciding which input to make active after a previously failed input\n * has recovered.\n */\nexport class InputPreference {\n  /** No preference — stay on the currently active input even after the other recovers. */\n  public static readonly EQUAL_INPUT_PREFERENCE = new InputPreference('EQUAL_INPUT_PREFERENCE');\n  /**\n   * Prefer the primary input — switch back to it once it has been free of failover\n   * conditions for the error-clear time.\n   */\n  public static readonly PRIMARY_INPUT_PREFERRED = new InputPreference('PRIMARY_INPUT_PREFERRED');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): InputPreference {\n    return new InputPreference(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/**\n * Properties for an input-loss failover condition.\n */\nexport interface InputLossFailoverProps {\n  /**\n   * The amount of time with no input detected before failover occurs.\n   * @default - MediaLive service default\n   */\n  readonly threshold?: Duration;\n}\n\n/**\n * Properties for an audio-silence failover condition.\n */\nexport interface AudioSilenceFailoverProps {\n  /**\n   * The audio selector (defined on the input attachment) that MediaLive monitors for\n   * silence. Pass the same `AudioSelector` instance you put in the attachment's\n   * `audioSelectors` — select your most important rendition.\n   */\n  readonly audioSelector: AudioSelector;\n  /**\n   * How long the audio must be silent (audio loss, or quieter than -50 dBFS) before\n   * failover occurs.\n   * @default - MediaLive service default\n   */\n  readonly threshold?: Duration;\n}\n\n/**\n * Properties for a video-black failover condition.\n */\nexport interface VideoBlackFailoverProps {\n  /**\n   * The fraction of white (0.0–1.0) below which a pixel is considered black. Every pixel in\n   * a frame must be below this threshold for the frame to count as black. For example, 0.1\n   * means 10% white (90% black).\n   * @default - MediaLive service default\n   */\n  readonly blackDetectThreshold?: number;\n  /**\n   * How long the content must be black before failover occurs.\n   * @default - MediaLive service default\n   */\n  readonly threshold?: Duration;\n}\n\n/**\n * A condition that, when met on the active input, triggers automatic input failover to the\n * secondary input. Create conditions with the static factory methods.\n */\nexport abstract class FailoverCondition {\n  /** Fail over when no input is detected for the threshold period. */\n  public static inputLoss(props: InputLossFailoverProps = {}): FailoverCondition {\n    return new InputLossFailoverCondition(props);\n  }\n  /** Fail over when the monitored audio selector is silent for the threshold period. */\n  public static audioSilence(props: AudioSilenceFailoverProps): FailoverCondition {\n    return new AudioSilenceFailoverCondition(props);\n  }\n  /** Fail over when the content is black for the threshold period. */\n  public static videoBlack(props: VideoBlackFailoverProps = {}): FailoverCondition {\n    return new VideoBlackFailoverCondition(props);\n  }\n\n  /** @internal */\n  public abstract _bind(): CfnChannel.FailoverConditionProperty;\n}\n\n/** @internal */\nclass InputLossFailoverCondition extends FailoverCondition {\n  constructor(private readonly props: InputLossFailoverProps) { super(); }\n  public _bind(): CfnChannel.FailoverConditionProperty {\n    return {\n      failoverConditionSettings: {\n        inputLossSettings: { inputLossThresholdMsec: this.props.threshold?.toMilliseconds() },\n      },\n    };\n  }\n}\n\n/** @internal */\nclass AudioSilenceFailoverCondition extends FailoverCondition {\n  constructor(private readonly props: AudioSilenceFailoverProps) { super(); }\n  public _bind(): CfnChannel.FailoverConditionProperty {\n    return {\n      failoverConditionSettings: {\n        audioSilenceSettings: {\n          audioSelectorName: this.props.audioSelector.name,\n          audioSilenceThresholdMsec: this.props.threshold?.toMilliseconds(),\n        },\n      },\n    };\n  }\n}\n\n/** @internal */\nclass VideoBlackFailoverCondition extends FailoverCondition {\n  constructor(private readonly props: VideoBlackFailoverProps) { super(); }\n  public _bind(): CfnChannel.FailoverConditionProperty {\n    return {\n      failoverConditionSettings: {\n        videoBlackSettings: {\n          blackDetectThreshold: this.props.blackDetectThreshold,\n          videoBlackThresholdMsec: this.props.threshold?.toMilliseconds(),\n        },\n      },\n    };\n  }\n}\n\n/**\n * Automatic input failover configuration for an input attachment. When the active (primary)\n * input meets any of the failover conditions, MediaLive switches to the secondary input\n * without restarting the channel. This is input-source redundancy, distinct from the\n * pipeline redundancy provided by `ChannelClass.STANDARD`.\n *\n * @see https://docs.aws.amazon.com/medialive/latest/ug/feature-automatic-input-failover.html\n */\nexport interface AutomaticInputFailover {\n  /**\n   * The secondary input to fail over to. Must be the same input class as the primary input.\n   *\n   * [disable-awslint:prefer-ref-interface]\n   */\n  readonly secondaryInput: IInput;\n  /**\n   * The conditions that trigger failover to the secondary input.\n   * @default - a single input-loss condition with the MediaLive service default threshold\n   */\n  readonly failoverConditions?: FailoverCondition[];\n  /**\n   * Which input to prefer once a failed input has recovered.\n   * @default - EQUAL_INPUT_PREFERENCE, applied by MediaLive\n   */\n  readonly inputPreference?: InputPreference;\n  /**\n   * How long a recovered input must remain free of failover conditions before it is\n   * considered healthy. Particularly relevant with `InputPreference.PRIMARY_INPUT_PREFERRED`.\n   * @default - MediaLive service default\n   */\n  readonly errorClearTime?: Duration;\n}\n\n/**\n * An input attachment definition for a channel.\n */\nexport interface InputAttachment {\n  /**\n   * The input to attach.\n   *\n   * [disable-awslint:prefer-ref-interface]\n   */\n  readonly input: IInput;\n  /**\n   * A name for this input attachment, used to reference it in schedule actions.\n   * @default - auto-generated\n   */\n  readonly inputAttachmentName?: string;\n  /**\n   * The source end behavior for file-based inputs.\n   * @default SourceEndBehavior.LOOP for MP4 and TS file inputs, SourceEndBehavior.CONTINUE for all others\n   */\n  readonly sourceEndBehavior?: SourceEndBehavior;\n  /**\n   * The input filter mode.\n   * @default InputFilter.AUTO\n   */\n  readonly inputFilter?: InputFilter;\n  /**\n   * The filter strength (1-5). 1 is minimal, 5 is strongest.\n   * @default 1\n   */\n  readonly filterStrength?: number;\n  /**\n   * Whether to enable the deblock filter.\n   * @default false\n   */\n  readonly deblockFilter?: boolean;\n  /**\n   * Whether to enable the denoise filter.\n   * @default false\n   */\n  readonly denoiseFilter?: boolean;\n  /**\n   * SMPTE-2038 ancillary data preference.\n   * @default Smpte2038DataPreference.IGNORE\n   */\n  readonly smpte2038DataPreference?: Smpte2038DataPreference;\n  /**\n   * Audio selectors to extract specific audio tracks from the input.\n   * @default - no audio selectors (uses default audio)\n   */\n  readonly audioSelectors?: AudioSelector[];\n  /**\n   * Caption selectors to extract specific caption tracks from the input.\n   * @default - no caption selectors\n   */\n  readonly captionSelectors?: CaptionSelector[];\n  /**\n   * The SCTE-35 PID override for this input.\n   * @default - auto-detect\n   */\n  readonly scte35Pid?: number;\n  /**\n   * Video selector settings for the input (color space, PID selection).\n   * @default - no video selector (use default video)\n   */\n  readonly videoSelector?: VideoSelectorSettings;\n  /**\n   * Network input settings (for URL pull inputs — HLS buffer, server validation).\n   * @default - no network input settings\n   */\n  readonly networkInputSettings?: NetworkInputSettings;\n  /**\n   * The logical interface names (MediaLive Anywhere) this input is wired to. Each name maps the\n   * input to a network interface on the channel's nodes.\n   * @default - no logical interface names\n   */\n  readonly logicalInterfaceNames?: string[];\n  /**\n   * Automatic input failover to a secondary input. When the active input meets any of the\n   * failover conditions, MediaLive switches to the secondary input without restarting the\n   * channel. This is input-source redundancy, distinct from the pipeline redundancy of\n   * `ChannelClass.STANDARD`.\n   * @default - no automatic input failover\n   */\n  readonly automaticInputFailover?: AutomaticInputFailover;\n}\n"]}

package/lib/input-security-group.d.ts

@@ -0,0 +1,51 @@
+import type { IResource } from 'aws-cdk-lib';
+import { Resource } from 'aws-cdk-lib';
+import type { IInputSecurityGroupRef, InputSecurityGroupReference } from 'aws-cdk-lib/aws-medialive';
+import type { Construct } from 'constructs';
+/**
+ * Represents a MediaLive Input Security Group.
+ */
+export interface IInputSecurityGroup extends IResource, IInputSecurityGroupRef {
+    /**
+     * The ARN of the input security group.
+     * @attribute
+     */
+    readonly inputSecurityGroupArn: string;
+    /**
+     * The ID of the input security group.
+     * @attribute
+     */
+    readonly inputSecurityGroupId: string;
+}
+/**
+ * Properties for creating a MediaLive Input Security Group.
+ */
+export interface InputSecurityGroupProps {
+    /**
+     * The list of IPv4 CIDR addresses to allow.
+     */
+    readonly allowlistRules: string[];
+    /**
+     * Tags to add to the input security group.
+     * @default - no tags
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Defines an AWS Elemental MediaLive Input Security Group.
+ *
+ * An input security group controls which IPv4 CIDR blocks can push content to a push-type input.
+ */
+export declare class InputSecurityGroup extends Resource implements IInputSecurityGroup {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /** Import an existing input security group by its ARN. The id is parsed out of the ARN. */
+    static fromInputSecurityGroupArn(scope: Construct, id: string, inputSecurityGroupArn: string): IInputSecurityGroup;
+    readonly inputSecurityGroupArn: string;
+    readonly inputSecurityGroupId: string;
+    /** A reference to this Input Security Group resource. */
+    get inputSecurityGroupRef(): InputSecurityGroupReference;
+    constructor(scope: Construct, id: string, props: InputSecurityGroupProps);
+}