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

package/lib/input.js

@@ -0,0 +1,803 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Input = exports.InputConfiguration = exports.MulticastProtocol = exports.SrtDecryptionAlgorithm = exports.InputSource = exports.InputType = exports.InputNetworkLocation = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_medialive_1 = require("aws-cdk-lib/aws-medialive");
+const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+const prop_injectable_1 = require("aws-cdk-lib/core/lib/prop-injectable");
+const shared_1 = require("./shared");
+/**
+ * The network location of a MediaLive input — the AWS cloud, or an on-premises network for
+ * MediaLive Anywhere.
+ */
+class InputNetworkLocation {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.InputNetworkLocation", version: "2.268.0-alpha.0" };
+    /** The input exists in the AWS cloud (the default). */
+    static AWS = new InputNetworkLocation('AWS');
+    /** The input exists in an on-premises network (MediaLive Anywhere). */
+    static ON_PREMISES = new InputNetworkLocation('ON_PREMISES');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new InputNetworkLocation(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.InputNetworkLocation = InputNetworkLocation;
+/**
+ * The type of MediaLive input. Users select an input type via
+ * the `InputConfiguration` factory methods, never by passing this type directly.
+ * @internal
+ */
+var InputType;
+(function (InputType) {
+    /** Push a UDP transport stream to MediaLive */
+    InputType["UDP_PUSH"] = "UDP_PUSH";
+    /** Push an RTP transport stream to MediaLive */
+    InputType["RTP_PUSH"] = "RTP_PUSH";
+    /** Push an RTMP stream to MediaLive */
+    InputType["RTMP_PUSH"] = "RTMP_PUSH";
+    /** Pull an RTMP stream from a server */
+    InputType["RTMP_PULL"] = "RTMP_PULL";
+    /** Pull HLS or TS content from a URL */
+    InputType["URL_PULL"] = "URL_PULL";
+    /** Pull an MP4 file from a URL */
+    InputType["MP4_FILE"] = "MP4_FILE";
+    /** Receive content from AWS Elemental MediaConnect */
+    InputType["MEDIACONNECT"] = "MEDIACONNECT";
+    /** Receive content from an Elemental Link device */
+    InputType["INPUT_DEVICE"] = "INPUT_DEVICE";
+    /** Receive uncompressed content via AWS CDI */
+    InputType["AWS_CDI"] = "AWS_CDI";
+    /** Pull a TS file from a URL */
+    InputType["TS_FILE"] = "TS_FILE";
+    /** Pull content from an SRT source (caller mode) */
+    InputType["SRT_CALLER"] = "SRT_CALLER";
+    /** Receive content pushed via SRT (listener mode) */
+    InputType["SRT_LISTENER"] = "SRT_LISTENER";
+    /** Receive multicast content. Requires `anywhereSettings` on the MediaLive Channel. */
+    InputType["MULTICAST"] = "MULTICAST";
+    /** Receive content via SMPTE 2110. Requires `anywhereSettings` on the MediaLive Channel. */
+    InputType["SMPTE_2110_RECEIVER_GROUP"] = "SMPTE_2110_RECEIVER_GROUP";
+    /** Receive content from an SDI source. Requires `anywhereSettings` on the MediaLive Channel. */
+    InputType["SDI"] = "SDI";
+    /** Receive content from a MediaConnect router */
+    InputType["MEDIACONNECT_ROUTER"] = "MEDIACONNECT_ROUTER";
+})(InputType || (exports.InputType = InputType = {}));
+/**
+ * A source for a pull-type input. Use the static factory methods to create.
+ */
+class InputSource {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.InputSource", version: "2.268.0-alpha.0" };
+    /**
+     * Create a source from a URL.
+     * @param url The URL where MediaLive pulls the source content from.
+     * @param options Optional credentials.
+     */
+    static url(url, options) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_InputSourceOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.url);
+            }
+            throw error;
+        }
+        return new UrlInputSource(url, options);
+    }
+    /**
+     * Create a source from an S3 bucket. Automatically grants read access
+     * to the channel's role.
+     *
+     * @param bucket The S3 bucket containing the source file.
+     * @param key The object key within the bucket (e.g. 'videos/intro.mp4').
+     */
+    static fromBucket(bucket, key) {
+        return new S3InputSource(bucket, key);
+    }
+    /** @internal */
+    _grantRead(_role) { }
+}
+exports.InputSource = InputSource;
+/** @internal */
+class UrlInputSource extends InputSource {
+    url;
+    options;
+    constructor(url, options) {
+        super();
+        this.url = url;
+        this.options = options;
+    }
+    _bind() {
+        return { url: this.url, username: this.options?.username, passwordParam: this.options?.password?.parameterName };
+    }
+    _grantRead(role) {
+        // MediaLive reads the password from SSM Parameter Store at channel runtime, so the
+        // channel role needs read access to the parameter (scoped to the parameter ARN).
+        this.options?.password?.grantRead(role);
+    }
+}
+/** @internal */
+class S3InputSource extends InputSource {
+    bucket;
+    url;
+    constructor(bucket, key) {
+        super();
+        this.bucket = bucket;
+        this.url = `s3ssl://${bucket.bucketName}/${key}`;
+    }
+    _bind() {
+        return { url: this.url };
+    }
+    _grantRead(role) {
+        this.bucket.grantRead(role);
+    }
+}
+/** The encryption algorithm for SRT decryption. */
+class SrtDecryptionAlgorithm {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.SrtDecryptionAlgorithm", version: "2.268.0-alpha.0" };
+    /** AES-128. */
+    static AES128 = new SrtDecryptionAlgorithm('AES128');
+    /** AES-192. */
+    static AES192 = new SrtDecryptionAlgorithm('AES192');
+    /** AES-256. */
+    static AES256 = new SrtDecryptionAlgorithm('AES256');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new SrtDecryptionAlgorithm(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.SrtDecryptionAlgorithm = SrtDecryptionAlgorithm;
+/** The transport protocol for a multicast source. */
+class MulticastProtocol {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.MulticastProtocol", version: "2.268.0-alpha.0" };
+    /** UDP transport. */
+    static UDP = new MulticastProtocol('udp');
+    /** RTP transport. */
+    static RTP = new MulticastProtocol('rtp');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new MulticastProtocol(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.MulticastProtocol = MulticastProtocol;
+/**
+ * Bind push-input destinations to their CFN shape.
+ * @internal
+ */
+function bindPushDestinations(destinations) {
+    return destinations?.map(d => ({
+        streamName: d.streamName,
+        network: d.network?.networkRef.networkId,
+        networkRoutes: d.networkRoutes?.map(r => ({ cidr: r.cidr, gateway: r.gateway })),
+        staticIpAddress: d.staticIpAddress,
+    }));
+}
+/**
+ * Bind a SMPTE 2110 SDP location to its CFN shape.
+ * @internal
+ */
+function bindSdpLocation(loc) {
+    return { sdpUrl: loc.sdpUrl, mediaIndex: loc.mediaIndex };
+}
+/**
+ * Defines the input configuration for a MediaLive Input.
+ *
+ * Use the static factory methods to create the appropriate configuration for your input type.
+ */
+class InputConfiguration {
+    _bindFn;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.InputConfiguration", version: "2.268.0-alpha.0" };
+    /**
+     * Create a URL pull input for HLS or TS streams.
+     *
+     * @example
+     *
+     *    InputConfiguration.urlPull([
+     *      InputSource.url('https://example.com/stream.m3u8'),
+     *    ]);
+     *
+     */
+    static urlPull(sources) {
+        return InputConfiguration.createPullInput(InputType.URL_PULL, sources);
+    }
+    /** Create an RTMP pull input. */
+    static rtmpPull(sources) {
+        return InputConfiguration.createPullInput(InputType.RTMP_PULL, sources);
+    }
+    /** Create an MP4 file pull input. */
+    static mp4File(sources) {
+        return InputConfiguration.createPullInput(InputType.MP4_FILE, sources);
+    }
+    /** Create a TS file pull input. */
+    static tsFile(sources) {
+        return InputConfiguration.createPullInput(InputType.TS_FILE, sources);
+    }
+    /**
+     * Create an RTMP push input.
+     *
+     * @example
+     *
+     *    declare const securityGroup: InputSecurityGroup;
+     *
+     *    InputConfiguration.rtmpPush({
+     *      inputSecurityGroups: [securityGroup],
+     *    });
+     *
+     */
+    static rtmpPush(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_PushInputProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rtmpPush);
+            }
+            throw error;
+        }
+        return new InputConfiguration(() => ({
+            type: InputType.RTMP_PUSH,
+            inputClass: props.destinations?.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',
+            inputSecurityGroups: props.inputSecurityGroups?.map(sg => sg.inputSecurityGroupRef.inputSecurityGroupId),
+            destinations: bindPushDestinations(props.destinations),
+        }));
+    }
+    /** Create an RTP push input. */
+    static rtpPush(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_PushInputProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rtpPush);
+            }
+            throw error;
+        }
+        return new InputConfiguration(() => ({
+            type: InputType.RTP_PUSH,
+            inputClass: props.destinations?.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',
+            inputSecurityGroups: props.inputSecurityGroups?.map(sg => sg.inputSecurityGroupRef.inputSecurityGroupId),
+            destinations: bindPushDestinations(props.destinations),
+        }));
+    }
+    /** Create a UDP push input. */
+    static udpPush(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_PushInputProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.udpPush);
+            }
+            throw error;
+        }
+        return new InputConfiguration(() => ({
+            type: InputType.UDP_PUSH,
+            inputClass: props.destinations?.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',
+            inputSecurityGroups: props.inputSecurityGroups?.map(sg => sg.inputSecurityGroupRef.inputSecurityGroupId),
+            destinations: bindPushDestinations(props.destinations),
+        }));
+    }
+    /**
+     * Create a MediaConnect router input configuration.
+     *
+     * @example
+     *
+     *    // Single pipeline with default AZ
+     *    InputConfiguration.mediaConnectRouter();
+     *
+     * @example
+     *
+     *    // Redundant pipelines with explicit AZs
+     *    InputConfiguration.mediaConnectRouter({
+     *      availabilityZones: ['us-east-1a', 'us-east-1b'],
+     *    });
+     *
+     */
+    static mediaConnectRouter(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_MediaConnectRouterInputProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.mediaConnectRouter);
+            }
+            throw error;
+        }
+        return new InputConfiguration((scope) => {
+            const stackAzs = scope ? aws_cdk_lib_1.Stack.of(scope).availabilityZones : [];
+            const azs = props?.availabilityZones ?? [stackAzs[0]];
+            if (azs.length < 1 || azs.length > 2) {
+                throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `RouterAzCount`, 'MediaConnect Router input requires 1 or 2 availability zones.');
+            }
+            const destinations = azs.map(az => ({
+                availabilityZoneName: az,
+            }));
+            return {
+                type: InputType.MEDIACONNECT_ROUTER,
+                inputClass: azs.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',
+                routerSettings: {
+                    destinations,
+                    encryptionType: props?.encryptionSecret ? 'CUSTOM' : 'AUTOMATIC',
+                    secretArn: props?.encryptionSecret?.secretArn,
+                },
+            };
+        });
+    }
+    /**
+     * Create a MediaConnect flow input configuration.
+     *
+     * @example
+     *
+     *    declare const role: iam.IRole;
+     *    declare const flow: mediaconnect.IFlowRef;
+     *
+     *    InputConfiguration.mediaConnect({
+     *      flows: [flow],
+     *      role,
+     *    });
+     *
+     */
+    static mediaConnect(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_MediaConnectInputProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.mediaConnect);
+            }
+            throw error;
+        }
+        if (props.flows.length < 1 || props.flows.length > 2) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `MediaConnectFlowsLimit`, 'You must specify 1 or 2 MediaConnect flows.');
+        }
+        return new InputConfiguration((scope) => {
+            const role = props.role ?? createInputRole(scope, 'MediaConnectRole');
+            return {
+                type: InputType.MEDIACONNECT,
+                inputClass: props.flows.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',
+                mediaConnectFlows: props.flows.map(f => ({ flowArn: f.flowRef.flowArn })),
+                roleArn: role.roleArn,
+                // Only auto-grant actions with auto-created role. A user-provided role
+                // is left alone — the caller adds its permissions.
+                mediaConnectFlowGrant: props.role === undefined ? { role } : undefined,
+            };
+        });
+    }
+    /** Create an SDI input configuration. */
+    static sdi(sources) {
+        return new InputConfiguration(() => ({
+            type: InputType.SDI,
+            inputClass: sources.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',
+            // MediaLive's SdiSources property expects the numeric SDI source ID, not the ARN.
+            sdiSources: sources.map(s => s.sdiSourceId),
+        }));
+    }
+    /** Create an Elemental Link input from one or two registered Link device IDs. */
+    static inputDevice(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_InputDeviceInputProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.inputDevice);
+            }
+            throw error;
+        }
+        if (props.deviceIds.length < 1 || props.deviceIds.length > 2) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `InputDeviceCount`, 'You must specify 1 or 2 input devices.');
+        }
+        return new InputConfiguration(() => ({
+            type: InputType.INPUT_DEVICE,
+            inputClass: props.deviceIds.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',
+            inputDevices: props.deviceIds.map(id => ({ id })),
+        }));
+    }
+    /**
+     * Create a CDI (uncompressed) input delivered into a VPC.
+     *
+     * MediaLive creates network interfaces in the supplied subnets and hands back the CDI push
+     * endpoints. The required EC2 permissions are granted to the role automatically.
+     */
+    static cdi(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_CdiInputProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.cdi);
+            }
+            throw error;
+        }
+        if (props.subnets.length !== 2) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `CdiSubnetCount`, 'CDI inputs require exactly 2 subnets in two different availability zones.');
+        }
+        const subnetIds = props.subnets.map(s => s.subnetRef.subnetId);
+        const securityGroupIds = props.securityGroups?.map(sg => sg.securityGroupRef.securityGroupId);
+        return new InputConfiguration((scope) => {
+            const role = props.role ?? createInputRole(scope, 'CdiRole');
+            return {
+                type: InputType.AWS_CDI,
+                inputClass: 'STANDARD',
+                roleArn: role.roleArn,
+                vpc: { subnetIds, securityGroupIds },
+                // Only auto-grant actions with auto-created role. A user-provided role
+                // is left alone — the caller adds its permissions.
+                vpcRoleGrant: props.role === undefined ? { role, subnetIds, securityGroupIds: securityGroupIds ?? [] } : undefined,
+            };
+        });
+    }
+    /** Create a multicast input. Requires `anywhereSettings` on the channel. */
+    static multicast(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_MulticastInputProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.multicast);
+            }
+            throw error;
+        }
+        if (props.sources.length < 1 || props.sources.length > 2) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `MulticastSourceCount`, 'You must specify 1 or 2 multicast sources.');
+        }
+        return new InputConfiguration(() => ({
+            type: InputType.MULTICAST,
+            inputClass: props.sources.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',
+            multicastSettings: {
+                sources: props.sources.map(s => ({
+                    url: `${(s.protocol ?? MulticastProtocol.UDP).value}://${s.address}:${s.port}`,
+                    sourceIp: s.sourceIp,
+                })),
+            },
+        }));
+    }
+    /** Create a SMPTE 2110 receiver group input. Requires `anywhereSettings` on the channel. */
+    static smpte2110ReceiverGroup(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_Smpte2110InputProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.smpte2110ReceiverGroup);
+            }
+            throw error;
+        }
+        if ((props.audioSdps?.length ?? 0) > 50) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `Smpte2110AudioSdpCount`, 'A SMPTE 2110 input supports at most 50 audio SDPs.');
+        }
+        if ((props.ancillarySdps?.length ?? 0) > 50) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `Smpte2110AncillarySdpCount`, 'A SMPTE 2110 input supports at most 50 ancillary SDPs.');
+        }
+        return new InputConfiguration(() => ({
+            type: InputType.SMPTE_2110_RECEIVER_GROUP,
+            smpte2110ReceiverGroupSettings: {
+                smpte2110ReceiverGroups: [{
+                        sdpSettings: {
+                            videoSdp: props.videoSdp ? bindSdpLocation(props.videoSdp) : undefined,
+                            audioSdps: props.audioSdps?.map(bindSdpLocation),
+                            ancillarySdps: props.ancillarySdps?.map(bindSdpLocation),
+                        },
+                    }],
+            },
+        }));
+    }
+    /**
+     * Create an SRT caller input configuration.
+     *
+     * @example
+     *
+     *    InputConfiguration.srtCaller([{
+     *      srtListenerAddress: '10.0.0.1',
+     *      srtListenerPort: 5000,
+     *    }]);
+     *
+     */
+    static srtCaller(sources) {
+        if (sources.length < 1 || sources.length > 2) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `SrtCallerSourcesLimit`, 'You must specify 1 or 2 SRT caller sources.');
+        }
+        return new InputConfiguration(() => ({
+            type: InputType.SRT_CALLER,
+            inputClass: sources.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',
+            srtSettings: {
+                srtCallerSources: sources.map(s => ({
+                    srtListenerAddress: s.srtListenerAddress,
+                    srtListenerPort: s.srtListenerPort.toString(),
+                    minimumLatency: s.minimumLatency?.toMilliseconds(),
+                    streamId: s.streamId,
+                    decryption: s.decryption ? {
+                        algorithm: s.decryption.algorithm?.value,
+                        passphraseSecretArn: s.decryption.passphraseSecret?.secretArn,
+                    } : undefined,
+                })),
+            },
+        }));
+    }
+    /** Create an SRT listener input configuration. */
+    static srtListener(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_SrtListenerInputProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.srtListener);
+            }
+            throw error;
+        }
+        return new InputConfiguration(() => ({
+            type: InputType.SRT_LISTENER,
+            inputClass: props.inputClass?.value ?? 'SINGLE_PIPELINE',
+            inputSecurityGroups: props.inputSecurityGroups.map(sg => sg.inputSecurityGroupRef.inputSecurityGroupId),
+            srtSettings: {
+                srtListenerSettings: {
+                    minimumLatency: props.minimumLatency?.toMilliseconds(),
+                    streamId: props.streamId,
+                    decryption: props.decryption ? {
+                        algorithm: props.decryption.algorithm?.value,
+                        passphraseSecretArn: props.decryption.passphraseSecret?.secretArn,
+                    } : undefined,
+                },
+            },
+        }));
+    }
+    static createPullInput(type, sources) {
+        if (sources.length < 1) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `PullInputSourcesMinimum`, 'You must specify at least 1 input source.');
+        }
+        if (sources.length > 2) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `PullInputSourcesLimit`, 'You cannot specify more than 2 input sources.');
+        }
+        return new InputConfiguration(() => {
+            return {
+                type,
+                inputClass: sources.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',
+                inputSources: sources,
+                sources: sources.map(s => s._bind()),
+            };
+        });
+    }
+    constructor(_bindFn) {
+        this._bindFn = _bindFn;
+    }
+    /** @internal */
+    _bind(scope) {
+        return this._bindFn(scope);
+    }
+}
+exports.InputConfiguration = InputConfiguration;
+/**
+ * Create the default IAM role for an input that MediaLive assumes (MediaConnect flow or CDI/VPC).
+ * The caller wires the specific managed/EC2 actions onto the role.
+ */
+function createInputRole(scope, id) {
+    if (!scope) {
+        throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `InputRoleScope`, 'Cannot auto-create an input role without a construct scope; provide an explicit `role`.');
+    }
+    return new aws_iam_1.Role(scope, id, {
+        assumedBy: new aws_iam_1.ServicePrincipal('medialive.amazonaws.com', {
+            conditions: {
+                StringEquals: { 'aws:SourceAccount': aws_cdk_lib_1.Aws.ACCOUNT_ID },
+                ArnLike: {
+                    'aws:SourceArn': aws_cdk_lib_1.Stack.of(scope).formatArn({
+                        service: 'medialive',
+                        resource: 'input',
+                        resourceName: '*',
+                        arnFormat: aws_cdk_lib_1.ArnFormat.COLON_RESOURCE_NAME,
+                    }),
+                },
+            },
+        }),
+    });
+}
+/**
+ * Defines an AWS Elemental MediaLive Input.
+ */
+let Input = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = aws_cdk_lib_1.Resource;
+    var Input = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Input = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.Input", version: "2.268.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-medialive-alpha.Input';
+        /** Import an existing input by its ARN. The id is parsed out of the ARN. */
+        static fromInputArn(scope, id, inputArn) {
+            const inputId = (0, shared_1.extractResourceId)(inputArn, 'Input');
+            class Import extends aws_cdk_lib_1.Resource {
+                inputArn = inputArn;
+                inputId = inputId;
+                inputClass = undefined;
+                inputType = undefined;
+                inputDestinations = undefined;
+                inputSources = undefined;
+                get inputRef() {
+                    return { inputId: this.inputId, inputArn: this.inputArn };
+                }
+                /** @internal Imported inputs own no sources, so granting is a no-op. */
+                _grantPermissions(_role) { }
+            }
+            return new Import(scope, id);
+        }
+        inputArn;
+        inputId;
+        inputClass;
+        inputType;
+        inputDestinations;
+        inputSources;
+        /** A reference to this Input resource. */
+        get inputRef() {
+            return { inputId: this.inputId, inputArn: this.inputArn };
+        }
+        inputSourceRefs;
+        constructor(scope, id, props) {
+            super(scope, id, {
+                physicalName: props.inputName ?? aws_cdk_lib_1.Lazy.string({ produce: () => aws_cdk_lib_1.Names.uniqueResourceName(this, { maxLength: 256 }) }),
+            });
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_InputProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, Input);
+                }
+                throw error;
+            }
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            const config = props.input._bind(this);
+            // Security-group rules: on-premises inputs don't support security groups, while cloud push
+            // inputs require at least one. Both always fail at deploy otherwise, so validate at synth.
+            const isOnPremises = props.inputNetworkLocation?.value === InputNetworkLocation.ON_PREMISES.value;
+            const hasSecurityGroups = (config.inputSecurityGroups?.length ?? 0) > 0;
+            const isPushInput = config.type === InputType.RTMP_PUSH
+                || config.type === InputType.RTP_PUSH
+                || config.type === InputType.UDP_PUSH;
+            if (isOnPremises && hasSecurityGroups) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `OnPremisesInputSecurityGroups`, 'on-premises inputs do not support input security groups; remove inputSecurityGroups for an ON_PREMISES input', this);
+            }
+            if (!isOnPremises && isPushInput && !hasSecurityGroups) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `PushInputSecurityGroupsRequired`, 'cloud push inputs require at least one input security group', this);
+            }
+            // SDI inputs are on-premises hardware sources — MediaLive always rejects an SDI input
+            // whose network location isn't ON_PREMISES, so fail fast at synth.
+            if (config.type === InputType.SDI && !isOnPremises) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `SdiInputRequiresOnPremises`, "an SDI input's inputNetworkLocation must be InputNetworkLocation.ON_PREMISES", this);
+            }
+            const resource = new aws_medialive_1.CfnInput(this, 'Resource', {
+                name: this.physicalName,
+                type: config.type,
+                roleArn: config.roleArn,
+                sources: config.sources,
+                destinations: config.destinations,
+                mediaConnectFlows: config.mediaConnectFlows,
+                inputDevices: config.inputDevices,
+                multicastSettings: config.multicastSettings,
+                smpte2110ReceiverGroupSettings: config.smpte2110ReceiverGroupSettings,
+                routerSettings: config.routerSettings,
+                srtSettings: config.srtSettings,
+                sdiSources: config.sdiSources,
+                vpc: config.vpc,
+                inputSecurityGroups: config.inputSecurityGroups,
+                inputNetworkLocation: props.inputNetworkLocation?.value,
+                tags: props.tags,
+            });
+            this.inputArn = resource.inputRef.inputArn;
+            this.inputId = resource.inputRef.inputId;
+            this.inputClass = config.inputClass;
+            this.inputType = config.type;
+            this.inputDestinations = resource.attrDestinations;
+            this.inputSources = resource.attrSources;
+            this.inputSourceRefs = config.inputSources ?? [];
+            // MediaConnect flow inputs: grant managed flow-management actions.
+            // Resource is `*` — service rejects flow-ARN-scoped grants.
+            if (config.mediaConnectFlowGrant) {
+                aws_iam_1.Grant.addToPrincipal({
+                    grantee: config.mediaConnectFlowGrant.role,
+                    actions: [
+                        'mediaconnect:ManagedDescribeFlow',
+                        'mediaconnect:ManagedAddOutput',
+                        'mediaconnect:ManagedRemoveOutput',
+                    ],
+                    resourceArns: ['*'],
+                }).applyBefore(resource);
+            }
+            // CDI/VPC inputs: Create/Delete scoped to ENI + subnets + SGs; Describe* needs `*`.
+            if (config.vpcRoleGrant) {
+                const stack = aws_cdk_lib_1.Stack.of(this);
+                const grant = config.vpcRoleGrant;
+                const networkInterfaceArn = stack.formatArn({ service: 'ec2', resource: 'network-interface', resourceName: '*' });
+                const subnetArns = grant.subnetIds.map(s => stack.formatArn({ service: 'ec2', resource: 'subnet', resourceName: s }));
+                const securityGroupArns = grant.securityGroupIds.map(sg => stack.formatArn({ service: 'ec2', resource: 'security-group', resourceName: sg }));
+                aws_iam_1.Grant.addToPrincipal({
+                    grantee: grant.role,
+                    actions: [
+                        'ec2:CreateNetworkInterface',
+                        'ec2:CreateNetworkInterfacePermission',
+                        'ec2:DeleteNetworkInterface',
+                    ],
+                    resourceArns: [networkInterfaceArn, ...subnetArns, ...securityGroupArns],
+                }).applyBefore(resource);
+                aws_iam_1.Grant.addToPrincipal({
+                    grantee: grant.role,
+                    actions: [
+                        'ec2:DescribeNetworkInterfaces',
+                        'ec2:DescribeSubnets',
+                        'ec2:DescribeSecurityGroups',
+                    ],
+                    resourceArns: ['*'], // Describe* actions don't support resource-level permissions
+                }).applyBefore(resource);
+            }
+        }
+        /** @internal */
+        _grantPermissions(role) {
+            this.inputSourceRefs.forEach(s => s._grantRead(role));
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return Input = _classThis;
+})();
+exports.Input = Input;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input.js","sourceRoot":"","sources":["input.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Duration, IResource } from 'aws-cdk-lib';\nimport { Resource, Lazy, Names, Stack, Aws, ArnFormat, UnscopedValidationError, ValidationError } from 'aws-cdk-lib';\nimport type { ISecurityGroupRef, ISubnetRef } from 'aws-cdk-lib/aws-ec2';\nimport type { IRole, IRoleRef } from 'aws-cdk-lib/aws-iam';\nimport { Grant, Role, ServicePrincipal } from 'aws-cdk-lib/aws-iam';\nimport type { IFlowRef } from 'aws-cdk-lib/aws-mediaconnect';\nimport type { IInputRef, InputReference, IInputSecurityGroupRef, INetworkRef } from 'aws-cdk-lib/aws-medialive';\nimport { CfnInput } from 'aws-cdk-lib/aws-medialive';\nimport type { IBucket } from 'aws-cdk-lib/aws-s3';\nimport type { ISecret } from 'aws-cdk-lib/aws-secretsmanager';\nimport type { IStringParameter } from 'aws-cdk-lib/aws-ssm';\nimport { lit } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport type { Construct } from 'constructs';\nimport type { ChannelClass } from './channel';\nimport type { NetworkRoute } from './network';\nimport type { ISdiSource } from './sdi-source';\nimport { extractResourceId } from './shared';\n\n/**\n * Represents a MediaLive Input.\n */\nexport interface IInput extends IResource, IInputRef {\n  /**\n   * The Amazon Resource Name (ARN) of the input.\n   * @attribute\n   */\n  readonly inputArn: string;\n  /**\n   * The ID of the input.\n   * @attribute\n   */\n  readonly inputId: string;\n  /**\n   * The input class (STANDARD or SINGLE_PIPELINE).\n   * Only available for input types where the pipeline count is known at construct time\n   * (e.g. mediaConnectRouter). Undefined for imported inputs and other types.\n   *\n   * @attribute\n   */\n  readonly inputClass?: string;\n  /**\n   * The input type (e.g. SRT_CALLER, MP4_FILE, URL_PULL).\n   * Undefined for imported inputs.\n   *\n   * @attribute\n   */\n  readonly inputType?: string;\n  /**\n   * For push inputs, the destination URLs where the upstream system sends content.\n   * @attribute\n   */\n  readonly inputDestinations?: string[];\n  /**\n   * For pull inputs, the source URLs where MediaLive pulls content from.\n   * @attribute\n   */\n  readonly inputSources?: string[];\n\n  /**\n   * Grant the channel role read access to this input's sources.\n   *\n   * Owned inputs grant access to the resources backing their sources (e.g. S3 buckets\n   * for file inputs); imported inputs are a no-op, since their sources aren't owned by\n   * this stack.\n   *\n   * @internal\n   */\n  _grantPermissions(role: IRoleRef): void;\n}\n\n/**\n * The network location of a MediaLive input — the AWS cloud, or an on-premises network for\n * MediaLive Anywhere.\n */\nexport class InputNetworkLocation {\n  /** The input exists in the AWS cloud (the default). */\n  public static readonly AWS = new InputNetworkLocation('AWS');\n  /** The input exists in an on-premises network (MediaLive Anywhere). */\n  public static readonly ON_PREMISES = new InputNetworkLocation('ON_PREMISES');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): InputNetworkLocation {\n    return new InputNetworkLocation(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 creating a MediaLive Input.\n */\nexport interface InputProps {\n  /**\n   * Input name.\n   * @default - auto-generated\n   */\n  readonly inputName?: string;\n  /**\n   * Input configuration that defines the input type and source settings.\n   */\n  readonly input: InputConfiguration;\n  /**\n   * The network location of the input — AWS cloud or on-premises (MediaLive Anywhere).\n   * @default - AWS, applied by MediaLive\n   */\n  readonly inputNetworkLocation?: InputNetworkLocation;\n  /**\n   * Tags to add to the input.\n   * @default - no tags\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * The type of MediaLive input. Users select an input type via\n * the `InputConfiguration` factory methods, never by passing this type directly.\n * @internal\n */\nexport enum InputType {\n  /** Push a UDP transport stream to MediaLive */\n  UDP_PUSH = 'UDP_PUSH',\n  /** Push an RTP transport stream to MediaLive */\n  RTP_PUSH = 'RTP_PUSH',\n  /** Push an RTMP stream to MediaLive */\n  RTMP_PUSH = 'RTMP_PUSH',\n  /** Pull an RTMP stream from a server */\n  RTMP_PULL = 'RTMP_PULL',\n  /** Pull HLS or TS content from a URL */\n  URL_PULL = 'URL_PULL',\n  /** Pull an MP4 file from a URL */\n  MP4_FILE = 'MP4_FILE',\n  /** Receive content from AWS Elemental MediaConnect */\n  MEDIACONNECT = 'MEDIACONNECT',\n  /** Receive content from an Elemental Link device */\n  INPUT_DEVICE = 'INPUT_DEVICE',\n  /** Receive uncompressed content via AWS CDI */\n  AWS_CDI = 'AWS_CDI',\n  /** Pull a TS file from a URL */\n  TS_FILE = 'TS_FILE',\n  /** Pull content from an SRT source (caller mode) */\n  SRT_CALLER = 'SRT_CALLER',\n  /** Receive content pushed via SRT (listener mode) */\n  SRT_LISTENER = 'SRT_LISTENER',\n  /** Receive multicast content. Requires `anywhereSettings` on the MediaLive Channel. */\n  MULTICAST = 'MULTICAST',\n  /** Receive content via SMPTE 2110. Requires `anywhereSettings` on the MediaLive Channel. */\n  SMPTE_2110_RECEIVER_GROUP = 'SMPTE_2110_RECEIVER_GROUP',\n  /** Receive content from an SDI source. Requires `anywhereSettings` on the MediaLive Channel. */\n  SDI = 'SDI',\n  /** Receive content from a MediaConnect router */\n  MEDIACONNECT_ROUTER = 'MEDIACONNECT_ROUTER',\n}\n\n/**\n * Options for a URL-based input source.\n */\nexport interface InputSourceOptions {\n  /**\n   * The username for accessing the upstream system.\n   * @default - no username\n   */\n  readonly username?: string;\n  /**\n   * The SSM parameter that holds the password for accessing the upstream system.\n   * @default - no password\n   */\n  readonly password?: IStringParameter;\n}\n\n/**\n * A source for a pull-type input. Use the static factory methods to create.\n */\nexport abstract class InputSource {\n  /**\n   * Create a source from a URL.\n   * @param url The URL where MediaLive pulls the source content from.\n   * @param options Optional credentials.\n   */\n  public static url(url: string, options?: InputSourceOptions): InputSource {\n    return new UrlInputSource(url, options);\n  }\n\n  /**\n   * Create a source from an S3 bucket. Automatically grants read access\n   * to the channel's role.\n   *\n   * @param bucket The S3 bucket containing the source file.\n   * @param key The object key within the bucket (e.g. 'videos/intro.mp4').\n   */\n  public static fromBucket(bucket: IBucket, key: string): InputSource {\n    return new S3InputSource(bucket, key);\n  }\n\n  /** @internal */\n  public abstract _bind(): { url: string; username?: string; passwordParam?: string };\n\n  /** @internal */\n  public _grantRead(_role: IRole): void {}\n}\n\n/** @internal */\nclass UrlInputSource extends InputSource {\n  constructor(private readonly url: string, private readonly options?: InputSourceOptions) { super(); }\n  public _bind() {\n    return { url: this.url, username: this.options?.username, passwordParam: this.options?.password?.parameterName };\n  }\n  public override _grantRead(role: IRole): void {\n    // MediaLive reads the password from SSM Parameter Store at channel runtime, so the\n    // channel role needs read access to the parameter (scoped to the parameter ARN).\n    this.options?.password?.grantRead(role);\n  }\n}\n\n/** @internal */\nclass S3InputSource extends InputSource {\n  public readonly url: string;\n  constructor(private readonly bucket: IBucket, key: string) {\n    super();\n    this.url = `s3ssl://${bucket.bucketName}/${key}`;\n  }\n  public _bind() {\n    return { url: this.url };\n  }\n  public override _grantRead(role: IRole): void {\n    this.bucket.grantRead(role);\n  }\n}\n\n/** Properties for a MediaConnect router input. */\nexport interface MediaConnectRouterInputProps {\n  /**\n   * The availability zones for the router input pipelines.\n   *\n   * Provide one AZ for a single pipeline, or two for redundant pipelines.\n   * If omitted, defaults to the stack's first availability zone (single pipeline).\n   *\n   * @default - single pipeline using the stack's first availability zone\n   */\n  readonly availabilityZones?: string[];\n  /**\n   * The Secrets Manager secret for custom encryption.\n   * If not provided, automatic encryption is used.\n   * @default - automatic encryption\n   */\n  readonly encryptionSecret?: ISecret;\n}\n\n/** Properties for a MediaConnect input. */\nexport interface MediaConnectInputProps {\n  /**\n   * The MediaConnect flows to use as sources (one, or two for pipeline redundancy).\n   */\n  readonly flows: IFlowRef[];\n  /**\n   * The IAM role MediaLive uses to manage the output it adds to the flow for this input.\n   *\n   * When omitted, a role is created and granted the required permissions.\n   * When you provide a role, no permissions are added — you own all the permissions it needs.\n   *\n   * @default - a role is created with the medialive.amazonaws.com service principal\n   *\n   * [disable-awslint:prefer-ref-interface]\n   */\n  readonly role?: IRole;\n}\n\n/** Properties for an SRT caller input. */\nexport interface SrtCallerSourceProps {\n  /** The address of the SRT listener to connect to. */\n  readonly srtListenerAddress: string;\n  /** The port of the SRT listener. */\n  readonly srtListenerPort: number;\n  /**\n   * The minimum latency.\n   * @default - service default\n   */\n  readonly minimumLatency?: Duration;\n  /**\n   * The stream ID for the SRT connection.\n   * @default - no stream ID\n   */\n  readonly streamId?: string;\n  /**\n   * Decryption settings for the SRT connection.\n   * @default - no decryption\n   */\n  readonly decryption?: SrtDecryptionProps;\n}\n\n/** The encryption algorithm for SRT decryption. */\nexport class SrtDecryptionAlgorithm {\n  /** AES-128. */\n  public static readonly AES128 = new SrtDecryptionAlgorithm('AES128');\n  /** AES-192. */\n  public static readonly AES192 = new SrtDecryptionAlgorithm('AES192');\n  /** AES-256. */\n  public static readonly AES256 = new SrtDecryptionAlgorithm('AES256');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): SrtDecryptionAlgorithm {\n    return new SrtDecryptionAlgorithm(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/** Properties for SRT decryption. */\nexport interface SrtDecryptionProps {\n  /**\n   * The encryption algorithm.\n   * @default - no algorithm\n   */\n  readonly algorithm?: SrtDecryptionAlgorithm;\n  /**\n   * The Secrets Manager secret containing the passphrase used to decrypt the content.\n   * @default - no passphrase\n   */\n  readonly passphraseSecret?: ISecret;\n}\n\n/** Properties for an SRT listener input. */\nexport interface SrtListenerInputProps {\n  /**\n   * Decryption settings for the SRT connection.\n   * @default - no decryption\n   */\n  readonly decryption?: SrtDecryptionProps;\n  /**\n   * The minimum latency.\n   * @default - service default\n   */\n  readonly minimumLatency?: Duration;\n  /**\n   * The stream ID that the upstream system uses when connecting to this listener.\n   * @default - no stream ID\n   */\n  readonly streamId?: string;\n  /**\n   * The input security groups. Required for SRT listener inputs.\n   */\n  readonly inputSecurityGroups: IInputSecurityGroupRef[];\n  /**\n   * Whether this is a STANDARD (two-pipeline) or SINGLE_PIPELINE input. A STANDARD input creates\n   * two listener endpoints for pipeline redundancy.\n   * @default ChannelClass.SINGLE_PIPELINE\n   */\n  readonly inputClass?: ChannelClass;\n}\n\n/** Properties for an Elemental Link input device input. */\nexport interface InputDeviceInputProps {\n  /** The IDs of one or two registered Elemental Link devices. Two provides pipeline redundancy. */\n  readonly deviceIds: string[];\n}\n\n/** The transport protocol for a multicast source. */\nexport class MulticastProtocol {\n  /** UDP transport. */\n  public static readonly UDP = new MulticastProtocol('udp');\n  /** RTP transport. */\n  public static readonly RTP = new MulticastProtocol('rtp');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): MulticastProtocol {\n    return new MulticastProtocol(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/** A source for a multicast input. */\nexport interface MulticastInputSource {\n  /** The multicast group address. */\n  readonly address: string;\n  /** The multicast port. */\n  readonly port: number;\n  /**\n   * The transport protocol.\n   * @default MulticastProtocol.UDP\n   */\n  readonly protocol?: MulticastProtocol;\n  /**\n   * Filter to a specific source IP (source-specific multicast).\n   * @default - accept any source\n   */\n  readonly sourceIp?: string;\n}\n\n/** Properties for a multicast input. Requires `anywhereSettings` on the channel. */\nexport interface MulticastInputProps {\n  /** The multicast sources. Provide two for a STANDARD (redundant-pipeline) channel. */\n  readonly sources: MulticastInputSource[];\n}\n\n/** A reference to an SDP file that describes a SMPTE 2110 stream to ingest. */\nexport interface Smpte2110SdpLocation {\n  /** The URL of the SDP file. */\n  readonly sdpUrl: string;\n  /**\n   * The index of the media stream within the SDP to ingest. Use when the SDP describes\n   * more than one stream of that media type.\n   * @default - service default\n   */\n  readonly mediaIndex?: number;\n}\n\n/**\n * Properties for a SMPTE 2110 receiver group input. Requires `anywhereSettings` on the channel.\n *\n * You specify the SDP files that describe the streams to ingest — one video SDP, and any\n * number of audio and ancillary SDPs.\n */\nexport interface Smpte2110InputProps {\n  /**\n   * The SDP describing the video stream.\n   * @default - no video stream\n   */\n  readonly videoSdp?: Smpte2110SdpLocation;\n  /**\n   * The SDPs describing the audio streams. Up to 50.\n   * @default - no audio streams\n   */\n  readonly audioSdps?: Smpte2110SdpLocation[];\n  /**\n   * The SDPs describing the ancillary data streams (SCTE-35 or captions). Up to 50.\n   * @default - no ancillary data streams\n   */\n  readonly ancillarySdps?: Smpte2110SdpLocation[];\n}\n\n/** Properties for a CDI (uncompressed) input. */\nexport interface CdiInputProps {\n  /**\n   * Two VPC subnets, in two different availability zones, for the CDI input network interfaces.\n   */\n  readonly subnets: ISubnetRef[];\n  /**\n   * Security groups to attach to the CDI input network interfaces.\n   * @default - VPC default security group\n   */\n  readonly securityGroups?: ISecurityGroupRef[];\n  /**\n   * The IAM role MediaLive assumes to create network interfaces in the VPC.\n   *\n   * When omitted, a role is created and granted the required permissions.\n   * When you provide a role, no permissions are added — you own all the permissions it needs.\n   *\n   * @default - a role is created with the medialive.amazonaws.com service principal\n   *\n   * [disable-awslint:prefer-ref-interface]\n   */\n  readonly role?: IRole;\n}\n\n/**\n * Properties for push-type inputs (RTMP_PUSH, RTP_PUSH, UDP_PUSH).\n */\nexport interface PushInputProps {\n  /**\n   * The input security groups that control which CIDR blocks can push to this input. Required for\n   * cloud inputs; must be omitted for on-premises inputs (`InputNetworkLocation.ON_PREMISES`),\n   * which do not support security groups.\n   * @default - none (only valid for on-premises inputs)\n   */\n  readonly inputSecurityGroups?: IInputSecurityGroupRef[];\n  /**\n   * The destinations for push inputs. For RTMP push, each destination can have a stream name.\n   * @default - MediaLive auto-generates destinations\n   */\n  readonly destinations?: PushInputDestination[];\n}\n\n/**\n * A destination for a push-type input.\n */\nexport interface PushInputDestination {\n  /**\n   * The stream name for RTMP push destinations (application name/instance).\n   * @default - auto-generated\n   */\n  readonly streamName?: string;\n  /**\n   * The MediaLive Anywhere network this push destination lives on. Required when the input's\n   * `inputNetworkLocation` is `ON_PREMISES`.\n   * @default - AWS-managed network\n   */\n  readonly network?: INetworkRef;\n  /**\n   * The routes to the push destination on the local network. Required for\n   * on-premises (`ON_PREMISES`) push inputs.\n   * @default - no routes\n   */\n  readonly networkRoutes?: NetworkRoute[];\n  /**\n   * A static IP address to assign to the push destination on the local network.\n   * @default - MediaLive Anywhere uses one from the IP pool specified on the selected network (service default)\n   */\n  readonly staticIpAddress?: string;\n}\n\n/**\n * Bind push-input destinations to their CFN shape.\n * @internal\n */\nfunction bindPushDestinations(destinations?: PushInputDestination[]): CfnInput.InputDestinationRequestProperty[] | undefined {\n  return destinations?.map(d => ({\n    streamName: d.streamName,\n    network: d.network?.networkRef.networkId,\n    networkRoutes: d.networkRoutes?.map(r => ({ cidr: r.cidr, gateway: r.gateway })),\n    staticIpAddress: d.staticIpAddress,\n  }));\n}\n\n/**\n * Internal bind result for InputConfiguration.\n * @internal\n */\ninterface InputBindConfig {\n  readonly type: InputType;\n  readonly inputClass?: string;\n  readonly inputSources?: InputSource[];\n  readonly sources?: CfnInput.InputSourceRequestProperty[];\n  readonly destinations?: CfnInput.InputDestinationRequestProperty[];\n  readonly mediaConnectFlows?: CfnInput.MediaConnectFlowRequestProperty[];\n  readonly inputDevices?: CfnInput.InputDeviceSettingsProperty[];\n  readonly multicastSettings?: CfnInput.MulticastSettingsCreateRequestProperty;\n  readonly smpte2110ReceiverGroupSettings?: CfnInput.Smpte2110ReceiverGroupSettingsProperty;\n  readonly routerSettings?: CfnInput.RouterSettingsProperty;\n  readonly srtSettings?: CfnInput.SrtSettingsRequestProperty;\n  readonly sdiSources?: string[];\n  readonly vpc?: CfnInput.InputVpcRequestProperty;\n  readonly roleArn?: string;\n  readonly inputSecurityGroups?: string[];\n  /**\n   * The role (and the flows it must manage) for a MediaConnect flow input. MediaLive\n   * assumes this role at input create/delete time to add/remove outputs on the flows,\n   * so it's granted the `mediaconnect:Managed*` flow-management actions.\n   */\n  readonly mediaConnectFlowGrant?: MediaConnectFlowGrant;\n  /**\n   * The role and VPC scope for a CDI/VPC input. MediaLive assumes this role to create the\n   * input's network interfaces, so it's granted the EC2 ENI actions scoped to the VPC.\n   */\n  readonly vpcRoleGrant?: VpcInputRoleGrant;\n}\n\n/**\n * The input role and VPC scope for a CDI/VPC input's EC2 ENI auto-grant.\n * @internal\n */\ninterface VpcInputRoleGrant {\n  readonly role: IRole;\n  readonly subnetIds: string[];\n  readonly securityGroupIds: string[];\n}\n\n/**\n * The input role for a MediaConnect flow input's auto-grant.\n * @internal\n */\ninterface MediaConnectFlowGrant {\n  readonly role: IRole;\n}\n\n/**\n * Bind a SMPTE 2110 SDP location to its CFN shape.\n * @internal\n */\nfunction bindSdpLocation(loc: Smpte2110SdpLocation): CfnInput.InputSdpLocationProperty {\n  return { sdpUrl: loc.sdpUrl, mediaIndex: loc.mediaIndex };\n}\n\n/**\n * Defines the input configuration for a MediaLive Input.\n *\n * Use the static factory methods to create the appropriate configuration for your input type.\n */\nexport class InputConfiguration {\n  /**\n   * Create a URL pull input for HLS or TS streams.\n   *\n   * @example\n   *\n   *    InputConfiguration.urlPull([\n   *      InputSource.url('https://example.com/stream.m3u8'),\n   *    ]);\n   *\n   */\n  public static urlPull(sources: InputSource[]): InputConfiguration {\n    return InputConfiguration.createPullInput(InputType.URL_PULL, sources);\n  }\n\n  /** Create an RTMP pull input. */\n  public static rtmpPull(sources: InputSource[]): InputConfiguration {\n    return InputConfiguration.createPullInput(InputType.RTMP_PULL, sources);\n  }\n\n  /** Create an MP4 file pull input. */\n  public static mp4File(sources: InputSource[]): InputConfiguration {\n    return InputConfiguration.createPullInput(InputType.MP4_FILE, sources);\n  }\n\n  /** Create a TS file pull input. */\n  public static tsFile(sources: InputSource[]): InputConfiguration {\n    return InputConfiguration.createPullInput(InputType.TS_FILE, sources);\n  }\n\n  /**\n   * Create an RTMP push input.\n   *\n   * @example\n   *\n   *    declare const securityGroup: InputSecurityGroup;\n   *\n   *    InputConfiguration.rtmpPush({\n   *      inputSecurityGroups: [securityGroup],\n   *    });\n   *\n   */\n  public static rtmpPush(props: PushInputProps): InputConfiguration {\n    return new InputConfiguration(() => ({\n      type: InputType.RTMP_PUSH,\n      inputClass: props.destinations?.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',\n      inputSecurityGroups: props.inputSecurityGroups?.map(sg => sg.inputSecurityGroupRef.inputSecurityGroupId),\n      destinations: bindPushDestinations(props.destinations),\n    }));\n  }\n\n  /** Create an RTP push input. */\n  public static rtpPush(props: PushInputProps): InputConfiguration {\n    return new InputConfiguration(() => ({\n      type: InputType.RTP_PUSH,\n      inputClass: props.destinations?.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',\n      inputSecurityGroups: props.inputSecurityGroups?.map(sg => sg.inputSecurityGroupRef.inputSecurityGroupId),\n      destinations: bindPushDestinations(props.destinations),\n    }));\n  }\n\n  /** Create a UDP push input. */\n  public static udpPush(props: PushInputProps): InputConfiguration {\n    return new InputConfiguration(() => ({\n      type: InputType.UDP_PUSH,\n      inputClass: props.destinations?.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',\n      inputSecurityGroups: props.inputSecurityGroups?.map(sg => sg.inputSecurityGroupRef.inputSecurityGroupId),\n      destinations: bindPushDestinations(props.destinations),\n    }));\n  }\n\n  /**\n   * Create a MediaConnect router input configuration.\n   *\n   * @example\n   *\n   *    // Single pipeline with default AZ\n   *    InputConfiguration.mediaConnectRouter();\n   *\n   * @example\n   *\n   *    // Redundant pipelines with explicit AZs\n   *    InputConfiguration.mediaConnectRouter({\n   *      availabilityZones: ['us-east-1a', 'us-east-1b'],\n   *    });\n   *\n   */\n  public static mediaConnectRouter(props?: MediaConnectRouterInputProps): InputConfiguration {\n    return new InputConfiguration((scope) => {\n      const stackAzs = scope ? Stack.of(scope).availabilityZones : [];\n      const azs = props?.availabilityZones ?? [stackAzs[0]];\n      if (azs.length < 1 || azs.length > 2) {\n        throw new UnscopedValidationError(lit`RouterAzCount`, 'MediaConnect Router input requires 1 or 2 availability zones.');\n      }\n      const destinations: CfnInput.RouterDestinationSettingsProperty[] = azs.map(az => ({\n        availabilityZoneName: az,\n      }));\n      return {\n        type: InputType.MEDIACONNECT_ROUTER,\n        inputClass: azs.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',\n        routerSettings: {\n          destinations,\n          encryptionType: props?.encryptionSecret ? 'CUSTOM' : 'AUTOMATIC',\n          secretArn: props?.encryptionSecret?.secretArn,\n        },\n      };\n    });\n  }\n\n  /**\n   * Create a MediaConnect flow input configuration.\n   *\n   * @example\n   *\n   *    declare const role: iam.IRole;\n   *    declare const flow: mediaconnect.IFlowRef;\n   *\n   *    InputConfiguration.mediaConnect({\n   *      flows: [flow],\n   *      role,\n   *    });\n   *\n   */\n  public static mediaConnect(props: MediaConnectInputProps): InputConfiguration {\n    if (props.flows.length < 1 || props.flows.length > 2) {\n      throw new UnscopedValidationError(lit`MediaConnectFlowsLimit`, 'You must specify 1 or 2 MediaConnect flows.');\n    }\n    return new InputConfiguration((scope) => {\n      const role = props.role ?? createInputRole(scope, 'MediaConnectRole');\n      return {\n        type: InputType.MEDIACONNECT,\n        inputClass: props.flows.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',\n        mediaConnectFlows: props.flows.map(f => ({ flowArn: f.flowRef.flowArn })),\n        roleArn: role.roleArn,\n        // Only auto-grant actions with auto-created role. A user-provided role\n        // is left alone — the caller adds its permissions.\n        mediaConnectFlowGrant: props.role === undefined ? { role } : undefined,\n      };\n    });\n  }\n\n  /** Create an SDI input configuration. */\n  public static sdi(sources: ISdiSource[]): InputConfiguration {\n    return new InputConfiguration(() => ({\n      type: InputType.SDI,\n      inputClass: sources.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',\n      // MediaLive's SdiSources property expects the numeric SDI source ID, not the ARN.\n      sdiSources: sources.map(s => s.sdiSourceId),\n    }));\n  }\n\n  /** Create an Elemental Link input from one or two registered Link device IDs. */\n  public static inputDevice(props: InputDeviceInputProps): InputConfiguration {\n    if (props.deviceIds.length < 1 || props.deviceIds.length > 2) {\n      throw new UnscopedValidationError(lit`InputDeviceCount`, 'You must specify 1 or 2 input devices.');\n    }\n    return new InputConfiguration(() => ({\n      type: InputType.INPUT_DEVICE,\n      inputClass: props.deviceIds.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',\n      inputDevices: props.deviceIds.map(id => ({ id })),\n    }));\n  }\n\n  /**\n   * Create a CDI (uncompressed) input delivered into a VPC.\n   *\n   * MediaLive creates network interfaces in the supplied subnets and hands back the CDI push\n   * endpoints. The required EC2 permissions are granted to the role automatically.\n   */\n  public static cdi(props: CdiInputProps): InputConfiguration {\n    if (props.subnets.length !== 2) {\n      throw new UnscopedValidationError(lit`CdiSubnetCount`, 'CDI inputs require exactly 2 subnets in two different availability zones.');\n    }\n    const subnetIds = props.subnets.map(s => s.subnetRef.subnetId);\n    const securityGroupIds = props.securityGroups?.map(sg => sg.securityGroupRef.securityGroupId);\n    return new InputConfiguration((scope) => {\n      const role = props.role ?? createInputRole(scope, 'CdiRole');\n      return {\n        type: InputType.AWS_CDI,\n        inputClass: 'STANDARD',\n        roleArn: role.roleArn,\n        vpc: { subnetIds, securityGroupIds },\n        // Only auto-grant actions with auto-created role. A user-provided role\n        // is left alone — the caller adds its permissions.\n        vpcRoleGrant: props.role === undefined ? { role, subnetIds, securityGroupIds: securityGroupIds ?? [] } : undefined,\n      };\n    });\n  }\n\n  /** Create a multicast input. Requires `anywhereSettings` on the channel. */\n  public static multicast(props: MulticastInputProps): InputConfiguration {\n    if (props.sources.length < 1 || props.sources.length > 2) {\n      throw new UnscopedValidationError(lit`MulticastSourceCount`, 'You must specify 1 or 2 multicast sources.');\n    }\n    return new InputConfiguration(() => ({\n      type: InputType.MULTICAST,\n      inputClass: props.sources.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',\n      multicastSettings: {\n        sources: props.sources.map(s => ({\n          url: `${(s.protocol ?? MulticastProtocol.UDP).value}://${s.address}:${s.port}`,\n          sourceIp: s.sourceIp,\n        })),\n      },\n    }));\n  }\n\n  /** Create a SMPTE 2110 receiver group input. Requires `anywhereSettings` on the channel. */\n  public static smpte2110ReceiverGroup(props: Smpte2110InputProps): InputConfiguration {\n    if ((props.audioSdps?.length ?? 0) > 50) {\n      throw new UnscopedValidationError(lit`Smpte2110AudioSdpCount`, 'A SMPTE 2110 input supports at most 50 audio SDPs.');\n    }\n    if ((props.ancillarySdps?.length ?? 0) > 50) {\n      throw new UnscopedValidationError(lit`Smpte2110AncillarySdpCount`, 'A SMPTE 2110 input supports at most 50 ancillary SDPs.');\n    }\n    return new InputConfiguration(() => ({\n      type: InputType.SMPTE_2110_RECEIVER_GROUP,\n      smpte2110ReceiverGroupSettings: {\n        smpte2110ReceiverGroups: [{\n          sdpSettings: {\n            videoSdp: props.videoSdp ? bindSdpLocation(props.videoSdp) : undefined,\n            audioSdps: props.audioSdps?.map(bindSdpLocation),\n            ancillarySdps: props.ancillarySdps?.map(bindSdpLocation),\n          },\n        }],\n      },\n    }));\n  }\n\n  /**\n   * Create an SRT caller input configuration.\n   *\n   * @example\n   *\n   *    InputConfiguration.srtCaller([{\n   *      srtListenerAddress: '10.0.0.1',\n   *      srtListenerPort: 5000,\n   *    }]);\n   *\n   */\n  public static srtCaller(sources: SrtCallerSourceProps[]): InputConfiguration {\n    if (sources.length < 1 || sources.length > 2) {\n      throw new UnscopedValidationError(lit`SrtCallerSourcesLimit`, 'You must specify 1 or 2 SRT caller sources.');\n    }\n    return new InputConfiguration(() => ({\n      type: InputType.SRT_CALLER,\n      inputClass: sources.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',\n      srtSettings: {\n        srtCallerSources: sources.map(s => ({\n          srtListenerAddress: s.srtListenerAddress,\n          srtListenerPort: s.srtListenerPort.toString(),\n          minimumLatency: s.minimumLatency?.toMilliseconds(),\n          streamId: s.streamId,\n          decryption: s.decryption ? {\n            algorithm: s.decryption.algorithm?.value,\n            passphraseSecretArn: s.decryption.passphraseSecret?.secretArn,\n          } : undefined,\n        })),\n      },\n    }));\n  }\n\n  /** Create an SRT listener input configuration. */\n  public static srtListener(props: SrtListenerInputProps): InputConfiguration {\n    return new InputConfiguration(() => ({\n      type: InputType.SRT_LISTENER,\n      inputClass: props.inputClass?.value ?? 'SINGLE_PIPELINE',\n      inputSecurityGroups: props.inputSecurityGroups.map(sg => sg.inputSecurityGroupRef.inputSecurityGroupId),\n      srtSettings: {\n        srtListenerSettings: {\n          minimumLatency: props.minimumLatency?.toMilliseconds(),\n          streamId: props.streamId,\n          decryption: props.decryption ? {\n            algorithm: props.decryption.algorithm?.value,\n            passphraseSecretArn: props.decryption.passphraseSecret?.secretArn,\n          } : undefined,\n        },\n      },\n    }));\n  }\n\n  private static createPullInput(type: InputType, sources: InputSource[]): InputConfiguration {\n    if (sources.length < 1) {\n      throw new UnscopedValidationError(lit`PullInputSourcesMinimum`, 'You must specify at least 1 input source.');\n    }\n    if (sources.length > 2) {\n      throw new UnscopedValidationError(lit`PullInputSourcesLimit`, 'You cannot specify more than 2 input sources.');\n    }\n    return new InputConfiguration(() => {\n      return {\n        type,\n        inputClass: sources.length === 2 ? 'STANDARD' : 'SINGLE_PIPELINE',\n        inputSources: sources,\n        sources: sources.map(s => s._bind()),\n      };\n    });\n  }\n\n  private constructor(private readonly _bindFn: (scope?: Construct) => InputBindConfig) {}\n\n  /** @internal */\n  public _bind(scope?: Construct): InputBindConfig {\n    return this._bindFn(scope);\n  }\n}\n\n/**\n * Create the default IAM role for an input that MediaLive assumes (MediaConnect flow or CDI/VPC).\n * The caller wires the specific managed/EC2 actions onto the role.\n */\nfunction createInputRole(scope: Construct | undefined, id: string): IRole {\n  if (!scope) {\n    throw new UnscopedValidationError(\n      lit`InputRoleScope`,\n      'Cannot auto-create an input role without a construct scope; provide an explicit `role`.',\n    );\n  }\n  return new Role(scope, id, {\n    assumedBy: new ServicePrincipal('medialive.amazonaws.com', {\n      conditions: {\n        StringEquals: { 'aws:SourceAccount': Aws.ACCOUNT_ID },\n        ArnLike: {\n          'aws:SourceArn': Stack.of(scope).formatArn({\n            service: 'medialive',\n            resource: 'input',\n            resourceName: '*',\n            arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n          }),\n        },\n      },\n    }),\n  });\n}\n\n/**\n * Defines an AWS Elemental MediaLive Input.\n */\n@propertyInjectable\nexport class Input extends Resource implements IInput {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-medialive-alpha.Input';\n\n  /** Import an existing input by its ARN. The id is parsed out of the ARN. */\n  public static fromInputArn(scope: Construct, id: string, inputArn: string): IInput {\n    const inputId = extractResourceId(inputArn, 'Input');\n\n    class Import extends Resource implements IInput {\n      public readonly inputArn = inputArn;\n      public readonly inputId = inputId;\n      public readonly inputClass = undefined;\n      public readonly inputType = undefined;\n      public readonly inputDestinations = undefined;\n      public readonly inputSources = undefined;\n      public get inputRef(): InputReference {\n        return { inputId: this.inputId, inputArn: this.inputArn };\n      }\n      /** @internal Imported inputs own no sources, so granting is a no-op. */\n      public _grantPermissions(_role: IRole): void {}\n    }\n    return new Import(scope, id);\n  }\n\n  public readonly inputArn: string;\n  public readonly inputId: string;\n  public readonly inputClass?: string;\n  public readonly inputType?: string;\n  public readonly inputDestinations?: string[];\n  public readonly inputSources?: string[];\n\n  /** A reference to this Input resource. */\n  public get inputRef(): InputReference {\n    return { inputId: this.inputId, inputArn: this.inputArn };\n  }\n\n  private readonly inputSourceRefs: InputSource[];\n\n  constructor(scope: Construct, id: string, props: InputProps) {\n    super(scope, id, {\n      physicalName: props.inputName ?? Lazy.string({ produce: () => Names.uniqueResourceName(this, { maxLength: 256 }) }),\n    });\n\n    addConstructMetadata(this, props);\n\n    const config = props.input._bind(this);\n\n    // Security-group rules: on-premises inputs don't support security groups, while cloud push\n    // inputs require at least one. Both always fail at deploy otherwise, so validate at synth.\n    const isOnPremises = props.inputNetworkLocation?.value === InputNetworkLocation.ON_PREMISES.value;\n    const hasSecurityGroups = (config.inputSecurityGroups?.length ?? 0) > 0;\n    const isPushInput = config.type === InputType.RTMP_PUSH\n      || config.type === InputType.RTP_PUSH\n      || config.type === InputType.UDP_PUSH;\n    if (isOnPremises && hasSecurityGroups) {\n      throw new ValidationError(\n        lit`OnPremisesInputSecurityGroups`,\n        'on-premises inputs do not support input security groups; remove inputSecurityGroups for an ON_PREMISES input',\n        this,\n      );\n    }\n    if (!isOnPremises && isPushInput && !hasSecurityGroups) {\n      throw new ValidationError(\n        lit`PushInputSecurityGroupsRequired`,\n        'cloud push inputs require at least one input security group',\n        this,\n      );\n    }\n    // SDI inputs are on-premises hardware sources — MediaLive always rejects an SDI input\n    // whose network location isn't ON_PREMISES, so fail fast at synth.\n    if (config.type === InputType.SDI && !isOnPremises) {\n      throw new ValidationError(\n        lit`SdiInputRequiresOnPremises`,\n        \"an SDI input's inputNetworkLocation must be InputNetworkLocation.ON_PREMISES\",\n        this,\n      );\n    }\n\n    const resource = new CfnInput(this, 'Resource', {\n      name: this.physicalName,\n      type: config.type,\n      roleArn: config.roleArn,\n      sources: config.sources,\n      destinations: config.destinations,\n      mediaConnectFlows: config.mediaConnectFlows,\n      inputDevices: config.inputDevices,\n      multicastSettings: config.multicastSettings,\n      smpte2110ReceiverGroupSettings: config.smpte2110ReceiverGroupSettings,\n      routerSettings: config.routerSettings,\n      srtSettings: config.srtSettings,\n      sdiSources: config.sdiSources,\n      vpc: config.vpc,\n      inputSecurityGroups: config.inputSecurityGroups,\n      inputNetworkLocation: props.inputNetworkLocation?.value,\n      tags: props.tags,\n    });\n\n    this.inputArn = resource.inputRef.inputArn;\n    this.inputId = resource.inputRef.inputId;\n    this.inputClass = config.inputClass;\n    this.inputType = config.type;\n    this.inputDestinations = resource.attrDestinations;\n    this.inputSources = resource.attrSources;\n    this.inputSourceRefs = config.inputSources ?? [];\n\n    // MediaConnect flow inputs: grant managed flow-management actions.\n    // Resource is `*` — service rejects flow-ARN-scoped grants.\n    if (config.mediaConnectFlowGrant) {\n      Grant.addToPrincipal({\n        grantee: config.mediaConnectFlowGrant.role,\n        actions: [\n          'mediaconnect:ManagedDescribeFlow',\n          'mediaconnect:ManagedAddOutput',\n          'mediaconnect:ManagedRemoveOutput',\n        ],\n        resourceArns: ['*'],\n      }).applyBefore(resource);\n    }\n\n    // CDI/VPC inputs: Create/Delete scoped to ENI + subnets + SGs; Describe* needs `*`.\n    if (config.vpcRoleGrant) {\n      const stack = Stack.of(this);\n      const grant = config.vpcRoleGrant;\n      const networkInterfaceArn = stack.formatArn({ service: 'ec2', resource: 'network-interface', resourceName: '*' });\n      const subnetArns = grant.subnetIds.map(s => stack.formatArn({ service: 'ec2', resource: 'subnet', resourceName: s }));\n      const securityGroupArns = grant.securityGroupIds.map(sg => stack.formatArn({ service: 'ec2', resource: 'security-group', resourceName: sg }));\n\n      Grant.addToPrincipal({\n        grantee: grant.role,\n        actions: [\n          'ec2:CreateNetworkInterface',\n          'ec2:CreateNetworkInterfacePermission',\n          'ec2:DeleteNetworkInterface',\n        ],\n        resourceArns: [networkInterfaceArn, ...subnetArns, ...securityGroupArns],\n      }).applyBefore(resource);\n      Grant.addToPrincipal({\n        grantee: grant.role,\n        actions: [\n          'ec2:DescribeNetworkInterfaces',\n          'ec2:DescribeSubnets',\n          'ec2:DescribeSecurityGroups',\n        ],\n        resourceArns: ['*'], // Describe* actions don't support resource-level permissions\n      }).applyBefore(resource);\n    }\n  }\n\n  /** @internal */\n  public _grantPermissions(role: IRole): void {\n    this.inputSourceRefs.forEach(s => s._grantRead(role));\n  }\n}\n"]}