@aws-cdk/aws-mediaconnect-alpha 2.263.0-alpha.0

package/lib/router-input.js

@@ -0,0 +1,1095 @@
+"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.RouterInput = exports.RouterInputConfiguration = exports.RouterInputProtocol = exports.SourcePriorityConfig = exports.PrimarySource = exports.ForwardErrorCorrection = exports.RouterInputTier = exports.RoutingScope = exports.RouterInputProtocolOptions = 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_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
+const aws_mediaconnect_1 = require("aws-cdk-lib/aws-mediaconnect");
+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 mediaconnect_grants_generated_1 = require("./mediaconnect-grants.generated");
+const shared_1 = require("./shared");
+/**
+ * Protocol options available for Router Input configurations
+ */
+class RouterInputProtocolOptions {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.RouterInputProtocolOptions", version: "2.263.0-alpha.0" };
+    /** Real-time Transport Protocol */
+    static RTP = new RouterInputProtocolOptions('RTP');
+    /** Reliable Internet Stream Transport */
+    static RIST = new RouterInputProtocolOptions('RIST');
+    /** Secure Reliable Transport - Caller mode */
+    static SRT_CALLER = new RouterInputProtocolOptions('SRT_CALLER');
+    /** Secure Reliable Transport - Listener mode */
+    static SRT_LISTENER = new RouterInputProtocolOptions('SRT_LISTENER');
+    /**
+     * Use a custom protocol value
+     * @param value The protocol string value
+     */
+    static of(value) {
+        return new RouterInputProtocolOptions(value);
+    }
+    /** @param value The protocol string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.RouterInputProtocolOptions = RouterInputProtocolOptions;
+/**
+ * Routing scope for the Router Input
+ */
+class RoutingScope {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.RoutingScope", version: "2.263.0-alpha.0" };
+    /** Route traffic within the same AWS region */
+    static REGIONAL = new RoutingScope('REGIONAL');
+    /** Route traffic globally across AWS regions */
+    static GLOBAL = new RoutingScope('GLOBAL');
+    /**
+     * Use a custom routing scope value
+     * @param value The routing scope string value
+     */
+    static of(value) {
+        return new RoutingScope(value);
+    }
+    /** @param value The routing scope string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.RoutingScope = RoutingScope;
+/**
+ * Routing tier based on your maximum bitrate requirements.
+ */
+class RouterInputTier {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.RouterInputTier", version: "2.263.0-alpha.0" };
+    /** Supports a maximum bitrate up to 100 megabits per second. */
+    static INPUT_100 = new RouterInputTier('INPUT_100');
+    /** Supports a maximum bitrate up to 50 megabits per second. */
+    static INPUT_50 = new RouterInputTier('INPUT_50');
+    /** Supports a maximum bitrate up to 20 megabits per second. */
+    static INPUT_20 = new RouterInputTier('INPUT_20');
+    /**
+     * Use a custom tier value
+     * @param value The tier string value
+     */
+    static of(value) {
+        return new RouterInputTier(value);
+    }
+    /** @param value The tier string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.RouterInputTier = RouterInputTier;
+/**
+ * Forward Error Correction (FEC) options for RTP protocol
+ */
+var ForwardErrorCorrection;
+(function (ForwardErrorCorrection) {
+    /** Enable Forward Error Correction */
+    ForwardErrorCorrection["ENABLED"] = "ENABLED";
+    /** Disable Forward Error Correction */
+    ForwardErrorCorrection["DISABLED"] = "DISABLED";
+})(ForwardErrorCorrection || (exports.ForwardErrorCorrection = ForwardErrorCorrection = {}));
+/**
+ * Identifies which protocol in a failover configuration's protocols array is primary.
+ */
+var PrimarySource;
+(function (PrimarySource) {
+    /** The first protocol in the failover protocols array. */
+    PrimarySource[PrimarySource["FIRST_SOURCE"] = 0] = "FIRST_SOURCE";
+    /** The second protocol in the failover protocols array. */
+    PrimarySource[PrimarySource["SECOND_SOURCE"] = 1] = "SECOND_SOURCE";
+})(PrimarySource || (exports.PrimarySource = PrimarySource = {}));
+/**
+ * Internal CFN-level values for the source priority mode.
+ * @internal
+ */
+var SourcePriorityMode;
+(function (SourcePriorityMode) {
+    /** Both sources are equal priority — the service picks one. */
+    SourcePriorityMode["NO_PRIORITY"] = "NO_PRIORITY";
+    /** One source is primary, the other is backup. */
+    SourcePriorityMode["PRIMARY_SECONDARY"] = "PRIMARY_SECONDARY";
+})(SourcePriorityMode || (SourcePriorityMode = {}));
+/**
+ * Source priority configuration for failover Router Input configurations.
+ */
+class SourcePriorityConfig {
+    _mode;
+    _primary;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.SourcePriorityConfig", version: "2.263.0-alpha.0" };
+    /**
+     * Treat both sources with equal priority — MediaConnect picks one when needed.
+     */
+    static none() {
+        return new SourcePriorityConfig(SourcePriorityMode.NO_PRIORITY, undefined);
+    }
+    /**
+     * Designate one of the two sources as primary; the other is treated as backup.
+     */
+    static primarySecondary(primary) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_PrimarySource(primary);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.primarySecondary);
+            }
+            throw error;
+        }
+        return new SourcePriorityConfig(SourcePriorityMode.PRIMARY_SECONDARY, primary);
+    }
+    constructor(_mode, _primary) {
+        this._mode = _mode;
+        this._primary = _primary;
+    }
+    /**
+     * Resolve the configuration to its CFN shape.
+     * @internal
+     */
+    _bind() {
+        return {
+            sourcePriorityMode: this._mode,
+            primarySourceIndex: this._primary,
+        };
+    }
+}
+exports.SourcePriorityConfig = SourcePriorityConfig;
+/**
+ * Identifies which configuration type a port conflict check is being performed for.
+ * @internal
+ */
+var ProtocolConfigType;
+(function (ProtocolConfigType) {
+    /** Failover-mode router input configuration. */
+    ProtocolConfigType["FAILOVER"] = "failover";
+    /** Merge-mode router input configuration. */
+    ProtocolConfigType["MERGE"] = "merge";
+})(ProtocolConfigType || (ProtocolConfigType = {}));
+/**
+ * Factory class for creating Router Input protocol configurations
+ */
+class RouterInputProtocol {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.RouterInputProtocol", version: "2.263.0-alpha.0" };
+    /**
+     * Create an RTP protocol configuration
+     * @param props RTP protocol properties
+     * @returns RouterInputProtocol instance configured for RTP
+     */
+    static rtp(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_RtpProtocolProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rtp);
+            }
+            throw error;
+        }
+        RouterInputProtocol.validatePort(props.port);
+        return new RouterInputProtocol(RouterInputProtocolOptions.RTP, {
+            rtp: {
+                port: props.port,
+                forwardErrorCorrection: props.forwardErrorCorrection,
+            },
+        }, props.port);
+    }
+    /**
+     * Create a RIST protocol configuration
+     * @param props RIST protocol properties
+     * @returns RouterInputProtocol instance configured for RIST
+     */
+    static rist(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_RistProtocolProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rist);
+            }
+            throw error;
+        }
+        RouterInputProtocol.validatePort(props.port);
+        return new RouterInputProtocol(RouterInputProtocolOptions.RIST, {
+            rist: {
+                port: props.port,
+                recoveryLatencyMilliseconds: props.recoveryLatency.toMilliseconds(),
+            },
+        }, props.port);
+    }
+    /**
+     * Create an SRT Listener protocol configuration
+     * @param props SRT Listener protocol properties
+     * @returns RouterInputProtocol instance configured for SRT Listener
+     */
+    static srtListener(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SrtListenerProtocolProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.srtListener);
+            }
+            throw error;
+        }
+        RouterInputProtocol.validatePort(props.port);
+        return new RouterInputProtocol(RouterInputProtocolOptions.SRT_LISTENER, {
+            srtListener: {
+                port: props.port,
+                minimumLatencyMilliseconds: props.minimumLatency.toMilliseconds(),
+            },
+        }, props.port, props.decryptionConfiguration);
+    }
+    /**
+     * Create an SRT Caller protocol configuration
+     * @param props SRT Caller protocol properties
+     * @returns RouterInputProtocol instance configured for SRT Caller
+     */
+    static srtCaller(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SrtCallerProtocolProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.srtCaller);
+            }
+            throw error;
+        }
+        RouterInputProtocol.validateSrtCallerPort(props.sourcePort);
+        return new RouterInputProtocol(RouterInputProtocolOptions.SRT_CALLER, {
+            srtCaller: {
+                sourceAddress: props.sourceAddress,
+                sourcePort: props.sourcePort,
+                minimumLatencyMilliseconds: props.minimumLatency.toMilliseconds(),
+                streamId: props.streamId,
+            },
+        }, undefined, props.decryptionConfiguration);
+    }
+    /**
+     * Validate that port is within the valid range (3000-30000)
+     */
+    static validatePort(port) {
+        if (!aws_cdk_lib_1.Token.isUnresolved(port) && (port < 3000 || port > 30000)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `RouterInputPortRange`, `Port must be between 3000 and 30000, got ${port}`);
+        }
+    }
+    /**
+     * Validate that SRT Caller port is within the valid range (0-65535)
+     */
+    static validateSrtCallerPort(port) {
+        if (!aws_cdk_lib_1.Token.isUnresolved(port) && (port < 0 || port > 65535)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `SrtCallerPortRange`, `SRT Caller port must be between 0 and 65535, got ${port}`);
+        }
+    }
+    _protocolName;
+    _config;
+    _port;
+    _decryption;
+    constructor(protocolName, config, port, decryption) {
+        this._protocolName = protocolName;
+        this._config = config;
+        this._port = port;
+        this._decryption = decryption;
+    }
+    /**
+     * Resolve this protocol to its CFN-ready form. Returns the protocol identifier,
+     * the CFN configuration shape (with SRT decryption auto-role materialized if needed),
+     * and the ingest port if the protocol has one.
+     *
+     * @param scope         Construct that scopes the auto-created decryption role
+     * @param routerInputArn  Optional ARN of the consuming router input — when provided,
+     *                        scopes the auto-created decryption role's trust policy.
+     *
+     * @internal
+     */
+    _bind(scope, routerInputArn) {
+        if (!this._decryption) {
+            return { name: this._protocolName, config: this._config, port: this._port };
+        }
+        const decryptionConfiguration = (0, shared_1.renderRouterSrtEncryption)(scope, 'DecryptionRole', this._decryption, routerInputArn);
+        if (this._config.srtListener) {
+            return {
+                name: this._protocolName,
+                port: this._port,
+                config: { srtListener: { ...this._config.srtListener, decryptionConfiguration } },
+            };
+        }
+        if (this._config.srtCaller) {
+            return {
+                name: this._protocolName,
+                port: this._port,
+                config: { srtCaller: { ...this._config.srtCaller, decryptionConfiguration } },
+            };
+        }
+        return { name: this._protocolName, config: this._config, port: this._port };
+    }
+    /**
+     * Compute the ingest URL (scheme://ipAddress:port) for this protocol, if it has
+     * a listening port.
+     *
+     * @internal
+     */
+    _ingestUrl(ipAddress) {
+        if (this._port === undefined)
+            return undefined;
+        return renderIngestUrl(this._protocolName.value, this._port, ipAddress);
+    }
+    /**
+     * The listening port for this protocol, if it has one. Undefined for SRT caller
+     * (which has a `sourcePort` pointing at the upstream listener, not a port the input
+     * itself listens on).
+     *
+     * @internal
+     */
+    _listeningPort() {
+        return this._port;
+    }
+    /**
+     * Whether two protocols share the same protocol identifier.
+     *
+     * @internal
+     */
+    _matchesKind(other) {
+        return this._protocolName.value === other._protocolName.value;
+    }
+    /**
+     * Whether this protocol is SRT (Caller or Listener).
+     *
+     * @internal
+     */
+    _isSrt() {
+        return this._protocolName.value === RouterInputProtocolOptions.SRT_CALLER.value
+            || this._protocolName.value === RouterInputProtocolOptions.SRT_LISTENER.value;
+    }
+    /**
+     * Validate port compatibility between this protocol and another in a failover or
+     * merge configuration. Throws on conflicts appropriate to the protocol kind.
+     *
+     * @internal
+     */
+    _validatePortConflicts(other, configType) {
+        const protocolValue = this._protocolName.value;
+        if (protocolValue === RouterInputProtocolOptions.RIST.value) {
+            const rist1 = this._config.rist;
+            const rist2 = other._config.rist;
+            if (rist1 && rist2 && 'port' in rist1 && 'port' in rist2) {
+                const port1 = rist1.port;
+                const port2 = rist2.port;
+                if (port1 === port2) {
+                    throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `DuplicateRistPort`, `${configType} configuration cannot use the same RIST port ${port1} for both protocols, ` +
+                        'each protocol must use a different port number');
+                }
+                if (Math.abs(port1 - port2) < 2) {
+                    throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `ConsecutiveRistPort`, `${configType} configuration cannot use consecutive RIST ports ${Math.min(port1, port2)} and ${Math.max(port1, port2)}, ` +
+                        'RIST protocols require non-consecutive ports to avoid overlapping ranges (e.g., use 6000 and 6002)');
+                }
+            }
+            return;
+        }
+        if (protocolValue === RouterInputProtocolOptions.RTP.value) {
+            const rtp1 = this._config.rtp;
+            const rtp2 = other._config.rtp;
+            if (rtp1 && rtp2 && 'port' in rtp1 && 'port' in rtp2 && rtp1.port === rtp2.port) {
+                throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `DuplicateRtpPort`, `${configType} configuration cannot use the same RTP port ${rtp1.port} for both protocols, ` +
+                    'each protocol must use a different port number');
+            }
+            return;
+        }
+        if (protocolValue === RouterInputProtocolOptions.SRT_LISTENER.value) {
+            const srt1 = this._config.srtListener;
+            const srt2 = other._config.srtListener;
+            if (srt1 && srt2 && 'port' in srt1 && 'port' in srt2 && srt1.port === srt2.port) {
+                throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `DuplicateSrtListenerPort`, `${configType} configuration cannot use the same SRT Listener port ${srt1.port} for both protocols, ` +
+                    'each protocol must use a different port number');
+            }
+        }
+    }
+}
+exports.RouterInputProtocol = RouterInputProtocol;
+/**
+ * Factory class for creating Router Input configurations
+ */
+class RouterInputConfiguration {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.RouterInputConfiguration", version: "2.263.0-alpha.0" };
+    /**
+     * Create a standard Router Input configuration with a single protocol
+     * @param props Standard configuration properties
+     * @returns RouterInputConfiguration instance for standard setup
+     */
+    static standard(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_StandardConfigurationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.standard);
+            }
+            throw error;
+        }
+        return new StandardRouterInputConfig(props);
+    }
+    /**
+     * Create a failover Router Input configuration with two matching protocols
+     * @param props Failover configuration properties
+     * @returns RouterInputConfiguration instance for failover setup
+     * @throws Error if protocols don't match or count is not exactly 2
+     */
+    static failover(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_FailoverConfigurationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.failover);
+            }
+            throw error;
+        }
+        if (!aws_cdk_lib_1.Token.isUnresolved(props.protocols) && props.protocols.length !== 2) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `FailoverProtocolCount`, `Failover configuration requires exactly 2 protocols, got ${props.protocols.length}`);
+        }
+        if (!props.protocols[0]._matchesKind(props.protocols[1])) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `FailoverProtocolMismatch`, 'Protocols must match');
+        }
+        props.protocols[0]._validatePortConflicts(props.protocols[1], ProtocolConfigType.FAILOVER);
+        return new FailoverRouterInputConfig(props);
+    }
+    /**
+     * Create a merge Router Input configuration with two matching non-SRT protocols
+     * @param props Merge configuration properties
+     * @returns RouterInputConfiguration instance for merge setup
+     * @throws Error if protocols don't match, count is not exactly 2, or SRT protocols are used
+     */
+    static merge(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MergeConfigurationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.merge);
+            }
+            throw error;
+        }
+        if (!aws_cdk_lib_1.Token.isUnresolved(props.protocols) && props.protocols.length !== 2) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `MergeProtocolCount`, `Merge configuration requires exactly 2 protocols, got ${props.protocols.length}`);
+        }
+        if (props.protocols.some(p => p._isSrt())) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `MergeSrtNotSupported`, 'SRT protocols are not supported in merge configuration');
+        }
+        if (!props.protocols[0]._matchesKind(props.protocols[1])) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `MergeProtocolMismatch`, 'Protocols must match');
+        }
+        props.protocols[0]._validatePortConflicts(props.protocols[1], ProtocolConfigType.MERGE);
+        return new MergeRouterInputConfig(props);
+    }
+    /**
+     * Create a MediaConnect Flow Router Input configuration without connecting to a specific flow
+     * Use this when you want to prepare the router input for a flow connection later
+     * @param props MediaConnect Flow configuration properties without connection
+     * @returns RouterInputConfiguration instance for MediaConnect Flow setup without connection
+     */
+    static mediaConnectFlowWithoutConnection(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MediaConnectFlowConfigurationWithoutConnectionProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.mediaConnectFlowWithoutConnection);
+            }
+            throw error;
+        }
+        return new MediaConnectFlowRouterInputConfig({ sourceTransitDecryption: props.sourceTransitDecryption }, props.availabilityZone);
+    }
+    /**
+     * Create a MediaConnect Flow Router Input configuration.
+     *
+     * Use this when the source flow already exists and you want to connect immediately.
+     *
+     * @param props MediaConnect Flow configuration properties
+     * @returns RouterInputConfiguration instance for MediaConnect Flow setup
+     */
+    static mediaConnectFlow(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MediaConnectFlowConfigurationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.mediaConnectFlow);
+            }
+            throw error;
+        }
+        return new MediaConnectFlowRouterInputConfig({
+            flow: props.flow,
+            flowOutput: props.flowOutput,
+            sourceTransitDecryption: props.sourceTransitDecryption,
+        });
+    }
+    /**
+     * Create a MediaLive Channel Router Input configuration.
+     *
+     * Use this when the source MediaLive channel already exists and you want to
+     * ingest from one of its outputs immediately.
+     *
+     * @param props MediaLive channel configuration properties
+     * @returns RouterInputConfiguration instance for MediaLive channel setup
+     */
+    static mediaLiveChannel(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MediaLiveChannelConfigurationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.mediaLiveChannel);
+            }
+            throw error;
+        }
+        return new MediaLiveChannelRouterInputConfig({
+            mediaLiveChannelArn: props.mediaLiveChannelArn,
+            mediaLiveChannelOutputName: props.mediaLiveChannelOutputName,
+            mediaLivePipelineId: props.mediaLivePipelineId,
+            sourceTransitDecryption: props.sourceTransitDecryption,
+        });
+    }
+    /**
+     * Create a MediaLive Channel Router Input configuration without a specific channel connection.
+     *
+     * Use this when you want to set up the router input before the target MediaLive channel exists.
+     *
+     * @param props MediaLive channel no-connection properties
+     * @returns RouterInputConfiguration instance for MediaLive channel setup without connection
+     */
+    static mediaLiveChannelWithoutConnection(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MediaLiveChannelConfigurationWithoutConnectionProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.mediaLiveChannelWithoutConnection);
+            }
+            throw error;
+        }
+        return new MediaLiveChannelRouterInputConfig({ sourceTransitDecryption: props.sourceTransitDecryption }, props.availabilityZone);
+    }
+}
+exports.RouterInputConfiguration = RouterInputConfiguration;
+/**
+ * Render an ingest URL string (scheme://ip:port). Used by `_ingestUrl()` on individual
+ * protocols and composed into the per-config-variant `_endpoints()` results.
+ *
+ * Extracts the base protocol for the URL scheme (e.g. SRT_LISTENER → srt, RTP → rtp).
+ */
+function renderIngestUrl(protocolName, port, ipAddress) {
+    const scheme = protocolName.toLowerCase().split('_')[0];
+    return aws_cdk_lib_1.Fn.join('', [`${scheme}://`, ipAddress, `:${port}`]);
+}
+/**
+ * Concrete variant: standard (single-protocol) router input configuration.
+ * @internal
+ */
+class StandardRouterInputConfig extends RouterInputConfiguration {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    _bind(scope, routerInputArn) {
+        const protocol = this.props.protocol._bind(scope, routerInputArn);
+        return {
+            config: {
+                standard: {
+                    networkInterfaceArn: this.props.networkInterface.routerNetworkInterfaceArn,
+                    protocol: protocol.name.value,
+                    protocolConfiguration: protocol.config,
+                },
+            },
+        };
+    }
+    _endpoints(ipAddress) {
+        const url = this.props.protocol._ingestUrl(ipAddress);
+        const port = this.props.protocol._listeningPort();
+        if (url === undefined || port === undefined)
+            return undefined;
+        return [{ url, port }];
+    }
+}
+/**
+ * Concrete variant: failover router input configuration.
+ * @internal
+ */
+class FailoverRouterInputConfig extends RouterInputConfiguration {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    _bind(scope, routerInputArn) {
+        const priority = (this.props.sourcePriority ?? SourcePriorityConfig.none())._bind();
+        return {
+            config: {
+                failover: {
+                    networkInterfaceArn: this.props.networkInterface.routerNetworkInterfaceArn,
+                    protocolConfigurations: this.props.protocols.map(p => p._bind(scope, routerInputArn).config),
+                    sourcePriorityMode: priority.sourcePriorityMode,
+                    primarySourceIndex: priority.primarySourceIndex,
+                },
+            },
+        };
+    }
+    _endpoints(ipAddress) {
+        const endpoints = [];
+        for (const p of this.props.protocols) {
+            const url = p._ingestUrl(ipAddress);
+            const port = p._listeningPort();
+            if (url === undefined || port === undefined)
+                return undefined;
+            endpoints.push({ url, port });
+        }
+        return endpoints;
+    }
+}
+/**
+ * Concrete variant: merge router input configuration.
+ * @internal
+ */
+class MergeRouterInputConfig extends RouterInputConfiguration {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    _bind(scope, routerInputArn) {
+        return {
+            config: {
+                merge: {
+                    networkInterfaceArn: this.props.networkInterface.routerNetworkInterfaceArn,
+                    protocolConfigurations: this.props.protocols.map(p => p._bind(scope, routerInputArn).config),
+                    mergeRecoveryWindowMilliseconds: this.props.mergeRecoveryWindow.toMilliseconds(),
+                },
+            },
+        };
+    }
+    _endpoints(ipAddress) {
+        const endpoints = [];
+        for (const p of this.props.protocols) {
+            const url = p._ingestUrl(ipAddress);
+            const port = p._listeningPort();
+            if (url === undefined || port === undefined)
+                return undefined;
+            endpoints.push({ url, port });
+        }
+        return endpoints;
+    }
+}
+/**
+ * Concrete variant: MediaConnect Flow router input configuration (with or without connection).
+ * @internal
+ */
+class MediaConnectFlowRouterInputConfig extends RouterInputConfiguration {
+    options;
+    availabilityZone;
+    constructor(options, availabilityZone) {
+        super();
+        this.options = options;
+        this.availabilityZone = availabilityZone;
+    }
+    _bind(scope, routerInputArn) {
+        return {
+            config: {
+                mediaConnectFlow: {
+                    flowArn: this.options.flow?.flowArn,
+                    flowOutputArn: this.options.flowOutput?.flowOutputArn,
+                    sourceTransitDecryption: (0, shared_1.renderTransitEncryption)(scope, 'SourceTransitDecryptionRole', this.options.sourceTransitDecryption, routerInputArn),
+                },
+            },
+            availabilityZone: this.availabilityZone,
+        };
+    }
+    _endpoints(_ipAddress) {
+        return undefined;
+    }
+}
+/**
+ * Concrete variant: MediaLive Channel router input configuration (with or without connection).
+ * @internal
+ */
+class MediaLiveChannelRouterInputConfig extends RouterInputConfiguration {
+    options;
+    availabilityZone;
+    constructor(options, availabilityZone) {
+        super();
+        this.options = options;
+        this.availabilityZone = availabilityZone;
+    }
+    _bind(scope, routerInputArn) {
+        return {
+            config: {
+                mediaLiveChannel: {
+                    mediaLiveChannelArn: this.options.mediaLiveChannelArn,
+                    mediaLiveChannelOutputName: this.options.mediaLiveChannelOutputName,
+                    mediaLivePipelineId: this.options.mediaLivePipelineId,
+                    sourceTransitDecryption: (0, shared_1.renderTransitEncryption)(scope, 'SourceTransitDecryptionRole', this.options.sourceTransitDecryption, routerInputArn),
+                },
+            },
+            availabilityZone: this.availabilityZone,
+        };
+    }
+    _endpoints(_ipAddress) {
+        return undefined;
+    }
+}
+/**
+ * A MediaConnect Router Input that receives media streams and routes them to outputs.
+ *
+ * Router Inputs support multiple configuration types:
+ * - Standard: Single protocol input
+ * - Failover: Two matching protocols for redundancy
+ * - Merge: Two matching non-SRT protocols for stream merging
+ * - MediaConnect Flow: Input from an existing MediaConnect Flow
+ */
+class RouterInputBase extends aws_cdk_lib_1.Resource {
+    /**
+     * A reference to this Router Input resource.
+     * Required by the auto-generated IRouterInputRef interface.
+     */
+    get routerInputRef() {
+        return { routerInputArn: this.routerInputArn };
+    }
+    /**
+     * Create a CloudWatch metric for this router input.
+     */
+    metric(metricName, props) {
+        return new aws_cloudwatch_1.Metric({
+            metricName,
+            namespace: 'AWS/MediaConnect',
+            ...props,
+            dimensionsMap: {
+                RouterInputARN: this.routerInputArn,
+                ...props?.dimensionsMap,
+            },
+        }).attachTo(this);
+    }
+    /**
+     * Metric for the bitrate of the router input's payload.
+     */
+    metricBitrate(props) {
+        return this.metric('RouterInputBitRate', {
+            statistic: 'avg',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.BITS_PER_SECOND,
+            ...props,
+        });
+    }
+    /**
+     * Metric for packets lost in transit that were not recovered by error correction.
+     */
+    metricNotRecoveredPackets(props) {
+        return this.metric('RouterInputNotRecoveredPackets', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            ...props,
+        });
+    }
+    /**
+     * Metric for the total number of packets received by the router input.
+     */
+    metricTotalPackets(props) {
+        return this.metric('RouterInputTotalPackets', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            ...props,
+        });
+    }
+    /**
+     * Metric for the router input connection state (1 connected, 0 disconnected). Applies to SRT sources only.
+     */
+    metricConnected(props) {
+        return this.metric('RouterInputConnected', {
+            statistic: 'min',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.NONE,
+            ...props,
+        });
+    }
+    /**
+     * Metric for continuity counter errors in the transport stream.
+     */
+    metricContinuityCounterErrors(props) {
+        return this.metric('RouterInputCCErrors', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            ...props,
+        });
+    }
+    /**
+     * Metric for the recovery latency of the input stream. Applies to RIST, SRT, and RTP-FEC.
+     */
+    metricLatency(props) {
+        return this.metric('RouterInputLatency', {
+            statistic: 'avg',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.MILLISECONDS,
+            ...props,
+        });
+    }
+    /**
+     * Metric for the number of times the router input has switched sources in Failover mode.
+     */
+    metricFailoverSwitches(props) {
+        return this.metric('RouterInputFailoverSwitches', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            ...props,
+        });
+    }
+}
+/**
+ * Defines an AWS Elemental MediaConnect Router Input.
+ */
+let RouterInput = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = RouterInputBase;
+    var RouterInput = 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);
+            RouterInput = _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-mediaconnect-alpha.RouterInput", version: "2.263.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-mediaconnect-alpha.RouterInput';
+        /**
+         * Import an existing Router Input from its ARN.
+         *
+         * Use `fromRouterInputAttributes()` instead if you need to expose `routerInputId`
+         * or `ipAddress` on the imported construct.
+         *
+         * @param scope The parent construct
+         * @param id The construct id
+         * @param routerInputArn The ARN of the Router Input
+         * @returns A Router Input construct
+         */
+        static fromRouterInputArn(scope, id, routerInputArn) {
+            return RouterInput.fromRouterInputAttributes(scope, id, { routerInputArn });
+        }
+        /**
+         * Import an existing Router Input from its attributes.
+         *
+         * Provide `routerInputId` and/or `ipAddress` when importing an input that was deployed
+         * externally — otherwise accessing those properties on the imported construct will throw.
+         *
+         * @param scope The parent construct
+         * @param id The construct id
+         * @param attrs The Router Input attributes
+         * @returns A Router Input construct
+         */
+        static fromRouterInputAttributes(scope, id, attrs) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_RouterInputAttributes(attrs);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.fromRouterInputAttributes);
+                }
+                throw error;
+            }
+            class Import extends RouterInputBase {
+                routerInputArn = attrs.routerInputArn;
+                createdAt = undefined;
+                updatedAt = undefined;
+                transitEncryptionSecret = undefined;
+                grants = mediaconnect_grants_generated_1.RouterInputGrants.fromRouterInput(this);
+                get endpoints() {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterInputEndpointsNotAvailableImported`, `'endpoints' is not available on imported RouterInput ${this.node.path}; only RouterInputs constructed in this app for listening protocol variants (RTP, RIST, SRT listener, including failover and merge) expose ingest endpoints`, this);
+                }
+                get routerInputId() {
+                    if (attrs.routerInputId)
+                        return attrs.routerInputId;
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterInputIdNotProvided`, `'routerInputId' is not available on imported RouterInput ${this.node.path}; pass it via fromRouterInputAttributes`, this);
+                }
+                get ipAddress() {
+                    if (attrs.ipAddress)
+                        return attrs.ipAddress;
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterInputIpAddressNotProvided`, `'ipAddress' is not available on imported RouterInput ${this.node.path}; pass it via fromRouterInputAttributes`, this);
+                }
+            }
+            return new Import(scope, id);
+        }
+        /**
+         * Returns the maximum bitrate in Mbps for a known tier, or undefined for custom tiers.
+         */
+        static tierLimitMbps(tier) {
+            if (tier.value === RouterInputTier.INPUT_20.value)
+                return 20;
+            if (tier.value === RouterInputTier.INPUT_50.value)
+                return 50;
+            if (tier.value === RouterInputTier.INPUT_100.value)
+                return 100;
+            return undefined;
+        }
+        routerInputArn;
+        routerInputId;
+        ipAddress;
+        createdAt;
+        updatedAt;
+        _endpoints;
+        transitEncryptionSecret;
+        grants;
+        get endpoints() {
+            if (this._endpoints === undefined) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterInputEndpointsNotAvailableConfig`, `'endpoints' is not available on this RouterInput ${this.node.path}; only listening protocol variants (RTP, RIST, SRT listener — including failover and merge built from those) expose ingest endpoints — SRT caller, MediaConnect Flow, and MediaLive Channel inputs do not`, this);
+            }
+            return this._endpoints;
+        }
+        constructor(scope, id, props) {
+            super(scope, id, {
+                physicalName: props.routerInputName ?? aws_cdk_lib_1.Lazy.string({ produce: () => aws_cdk_lib_1.Names.uniqueResourceName(this, { maxLength: 128 }) }),
+            });
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_RouterInputProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, RouterInput);
+                }
+                throw error;
+            }
+            // Validate router input name if provided
+            if (props.routerInputName != null && props.routerInputName !== '' && !aws_cdk_lib_1.Token.isUnresolved(props.routerInputName)) {
+                if (props.routerInputName.length > 128) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterInputNameLength`, `Router input name must be between 1 and 128 characters, got ${props.routerInputName.length}`, this);
+                }
+                if (!/^[a-zA-Z0-9-]+$/.test(props.routerInputName)) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterInputNameFormat`, `Router input name must contain only alphanumeric characters and hyphens, got '${props.routerInputName}'`, this);
+                }
+            }
+            // Validate maximum bitrate
+            if (!props.maximumBitrate.isUnresolved() && props.maximumBitrate.toBps() < 1000000) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterInputMinBitrate`, `Maximum bitrate must be at least 1,000,000 bits/s (1 Mbps), got ${props.maximumBitrate.toBps()}`, this);
+            }
+            // Validate bitrate does not exceed tier limit
+            const resolvedTier = props.tier ?? RouterInputTier.INPUT_20;
+            const tierMbps = RouterInput.tierLimitMbps(resolvedTier);
+            if ((0, shared_1.exceedsRouterTierBitrate)(tierMbps, props.maximumBitrate)) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterInputBitrateExceedsTier`, `Maximum bitrate ${props.maximumBitrate.toBps() / 1_000_000} Mbps exceeds the ${resolvedTier.value} tier limit of ${tierMbps} Mbps`, this);
+            }
+            // Validate maintenance time format
+            if (props.maintenanceConfiguration) {
+                (0, shared_1.validateMaintenanceTime)(props.maintenanceConfiguration.time);
+            }
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            const stack = aws_cdk_lib_1.Stack.of(this);
+            const targetRegion = props.regionName ?? stack.region;
+            // Wildcard the id — pinning the live ARN (attrArn) would create a role → router-input → role cycle.
+            const routerInputArn = stack.formatArn({
+                service: 'mediaconnect',
+                region: targetRegion,
+                resource: 'routerInput',
+                resourceName: '*',
+                arnFormat: aws_cdk_lib_1.ArnFormat.COLON_RESOURCE_NAME,
+            });
+            const configBind = props.configuration._bind(this, routerInputArn);
+            // Validate AZ matches region if provided
+            if (configBind.availabilityZone && !configBind.availabilityZone.startsWith(targetRegion)) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterInputAzRegionMismatch`, `Availability zone '${configBind.availabilityZone}' must be within region '${targetRegion}'`, this);
+            }
+            const transit = (0, shared_1.resolveTransitEncryption)(this, 'TransitEncryptionRole', props.transitEncryption, routerInputArn);
+            const routerinput = new aws_mediaconnect_1.CfnRouterInput(this, 'Resource', {
+                name: this.physicalName,
+                maximumBitrate: props.maximumBitrate.toBps(),
+                tier: (props.tier ?? RouterInputTier.INPUT_20).value,
+                routingScope: props.routingScope.value,
+                maintenanceConfiguration: props.maintenanceConfiguration ? {
+                    preferredDayTime: props.maintenanceConfiguration,
+                } : {
+                    default: {},
+                },
+                configuration: configBind.config,
+                transitEncryption: transit.config,
+                regionName: targetRegion,
+                availabilityZone: configBind.availabilityZone,
+                tags: props.tags ? (0, shared_1.renderTags)(props.tags) : undefined,
+            });
+            this.routerInputArn = routerinput.attrArn;
+            this.routerInputId = routerinput.attrId;
+            this.ipAddress = routerinput.attrIpAddress;
+            this.createdAt = routerinput.attrCreatedAt;
+            this.updatedAt = routerinput.attrUpdatedAt;
+            // Without this the router input can be created before the
+            // policy is attached ("access denied" at create time). Ordering the grant before the
+            // router input pulls the policy in as a dependency.
+            transit.grant?.applyBefore(routerinput);
+            // Compute ingest endpoints for protocol-based variants
+            this._endpoints = props.configuration._endpoints(routerinput.attrIpAddress);
+            // Store the transit encryption secret if explicitly provided
+            this.transitEncryptionSecret = props.transitEncryption?.secret;
+            this.grants = mediaconnect_grants_generated_1.RouterInputGrants.fromRouterInput(this);
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return RouterInput = _classThis;
+})();
+exports.RouterInput = RouterInput;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router-input.js","sourceRoot":"","sources":["router-input.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Bitrate, IResource } from 'aws-cdk-lib';\nimport { ArnFormat, Duration, Fn, Lazy, Names, Resource, Stack, Token, UnscopedValidationError, ValidationError } from 'aws-cdk-lib';\nimport type { MetricOptions } from 'aws-cdk-lib/aws-cloudwatch';\nimport { Metric, Unit } from 'aws-cdk-lib/aws-cloudwatch';\nimport { CfnRouterInput } from 'aws-cdk-lib/aws-mediaconnect';\nimport type { IRouterInputRef, RouterInputReference } from 'aws-cdk-lib/aws-mediaconnect';\nimport type { ISecret } from 'aws-cdk-lib/aws-secretsmanager';\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 { IFlow } from './flow';\nimport type { IFlowOutput } from './flow-output';\nimport { RouterInputGrants } from './mediaconnect-grants.generated';\nimport type { IRouterNetworkInterface } from './router-network-interface';\nimport type { MaintenanceDay, MediaLivePipeline, RouterSrtEncryption, TransitEncryption } from './shared';\nimport { renderTags, exceedsRouterTierBitrate, renderRouterSrtEncryption, renderTransitEncryption, resolveTransitEncryption, validateMaintenanceTime } from './shared';\n\n/**\n * Protocol options available for Router Input configurations\n */\nexport class RouterInputProtocolOptions {\n  /** Real-time Transport Protocol */\n  public static readonly RTP = new RouterInputProtocolOptions('RTP');\n  /** Reliable Internet Stream Transport */\n  public static readonly RIST = new RouterInputProtocolOptions('RIST');\n  /** Secure Reliable Transport - Caller mode */\n  public static readonly SRT_CALLER = new RouterInputProtocolOptions('SRT_CALLER');\n  /** Secure Reliable Transport - Listener mode */\n  public static readonly SRT_LISTENER = new RouterInputProtocolOptions('SRT_LISTENER');\n\n  /**\n   * Use a custom protocol value\n   * @param value The protocol string value\n   */\n  public static of(value: string): RouterInputProtocolOptions {\n    return new RouterInputProtocolOptions(value);\n  }\n\n  /** @param value The protocol string value */\n  private constructor(public readonly value: string) {}\n\n  /** Returns the string value */\n  public toString(): string {\n    return this.value;\n  }\n}\n\n/**\n * A single ingest endpoint where the router input listens for upstream content.\n *\n * Failover and merge configurations expose two endpoints; standard configurations\n * expose one. Returned by {@link IRouterInput.endpoints}.\n */\nexport interface RouterInputEndpoint {\n  /**\n   * The full ingest URL combining protocol scheme, IP, and port. For example:\n   * `srt://203.0.113.10:5000` or `rtp://203.0.113.10:5001`.\n   */\n  readonly url: string;\n\n  /**\n   * The listening port at which the router input accepts upstream content.\n   */\n  readonly port: number;\n}\n\n/**\n * Interface for Router Input\n */\nexport interface IRouterInput extends IResource, IRouterInputRef {\n  /**\n   * The Amazon Resource Name (ARN) of the router input.\n   *\n   * @attribute\n   */\n  readonly routerInputArn: string;\n\n  /**\n   * The unique identifier of the router input.\n   *\n   * @attribute\n   */\n  readonly routerInputId: string;\n\n  /**\n   * The IP address of the router input.\n   *\n   * @attribute\n   */\n  readonly ipAddress: string;\n\n  /**\n   * The timestamp when the router input was created.\n   *\n   * @attribute\n   */\n  readonly createdAt?: string;\n\n  /**\n   * The timestamp when the router input was last updated.\n   *\n   * @attribute\n   */\n  readonly updatedAt?: string;\n\n  /**\n   * The ingest endpoints (URL + port) where the router input listens.\n   *\n   * Returns one entry for standard protocol-based variants (RTP, RIST, SRT listener),\n   * and one entry per source for failover and merge configurations built from those\n   * protocols. For example a failover RTP input will return:\n   *\n   * ```\n   * [\n   *   { url: 'rtp://203.0.113.10:5000', port: 5000 },\n   *   { url: 'rtp://203.0.113.10:5001', port: 5001 },\n   * ]\n   * ```\n   *\n   * Accessing this on SRT caller (where the router input dials out to a remote\n   * source), MediaConnect Flow, MediaLive Channel, or imported inputs throws — those\n   * variants do not expose host:port pairs the input listens on.\n   */\n  readonly endpoints: RouterInputEndpoint[];\n\n  /**\n   * The Secrets Manager secret containing the transit encryption passphrase.\n   *\n   * Only available when the Router Input was created with explicit\n   * `transitEncryption` configuration. Not available for\n   * automatic encryption or imported inputs.\n   */\n  readonly transitEncryptionSecret?: ISecret;\n\n  /**\n   * Collection of grant methods for this router input.\n   */\n  readonly grants: RouterInputGrants;\n\n  /**\n   * Create a CloudWatch metric for this router input.\n   *\n   * Router input metrics are dimensioned by `RouterInputARN`. See the MediaConnect\n   * documentation for available metric names (e.g. `RouterInputBitRate`,\n   * `RouterInputNotRecoveredPackets`).\n   */\n  metric(metricName: string, props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the bitrate of the router input's payload.\n   * @default - average over 60 seconds\n   */\n  metricBitrate(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for packets lost in transit that were not recovered by error correction.\n   * @default - sum over 60 seconds\n   */\n  metricNotRecoveredPackets(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the total number of packets received by the router input.\n   * @default - sum over 60 seconds\n   */\n  metricTotalPackets(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the router input connection state (1 connected, 0 disconnected). Applies to SRT sources only.\n   * @default - minimum over 60 seconds\n   */\n  metricConnected(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for continuity counter errors in the transport stream.\n   * @default - sum over 60 seconds\n   */\n  metricContinuityCounterErrors(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the recovery latency of the input stream. Applies to RIST, SRT, and RTP-FEC.\n   * @default - average over 60 seconds\n   */\n  metricLatency(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the number of times the router input has switched sources in Failover mode.\n   * @default - sum over 60 seconds\n   */\n  metricFailoverSwitches(props?: MetricOptions): Metric;\n}\n\n/**\n * Routing scope for the Router Input\n */\nexport class RoutingScope {\n  /** Route traffic within the same AWS region */\n  public static readonly REGIONAL = new RoutingScope('REGIONAL');\n  /** Route traffic globally across AWS regions */\n  public static readonly GLOBAL = new RoutingScope('GLOBAL');\n\n  /**\n   * Use a custom routing scope value\n   * @param value The routing scope string value\n   */\n  public static of(value: string): RoutingScope {\n    return new RoutingScope(value);\n  }\n\n  /** @param value The routing scope string value */\n  private constructor(public readonly value: string) {}\n\n  /** Returns the string value */\n  public toString(): string {\n    return this.value;\n  }\n}\n\n/**\n * Routing tier based on your maximum bitrate requirements.\n */\nexport class RouterInputTier {\n  /** Supports a maximum bitrate up to 100 megabits per second. */\n  public static readonly INPUT_100 = new RouterInputTier('INPUT_100');\n  /** Supports a maximum bitrate up to 50 megabits per second. */\n  public static readonly INPUT_50 = new RouterInputTier('INPUT_50');\n  /** Supports a maximum bitrate up to 20 megabits per second. */\n  public static readonly INPUT_20 = new RouterInputTier('INPUT_20');\n\n  /**\n   * Use a custom tier value\n   * @param value The tier string value\n   */\n  public static of(value: string): RouterInputTier {\n    return new RouterInputTier(value);\n  }\n\n  /** @param value The tier string value */\n  private constructor(public readonly value: string) {}\n\n  /** Returns the string value */\n  public toString(): string {\n    return this.value;\n  }\n}\n\n/**\n * Configuration for scheduled maintenance windows\n */\nexport interface MaintenanceConfiguration {\n  /** Day of the week for maintenance (e.g., 'Monday', 'Tuesday') */\n  readonly day: MaintenanceDay;\n  /** Time of day for maintenance in HH:MM format (e.g., '02:00') */\n  readonly time: string;\n}\n\n/**\n * Properties for creating a Router Input\n */\nexport interface RouterInputProps {\n  /**\n   * Name of the Router Input\n   * @default - Generated automatically\n   */\n  readonly routerInputName?: string;\n  /** Maximum bitrate in bits per second that the Router Input can handle */\n  readonly maximumBitrate: Bitrate;\n  /** Routing scope for the Router Input */\n  readonly routingScope: RoutingScope;\n  /**\n   * Select a tier based on your maximum bitrate requirements.\n   *\n   * @default RouterInputTier.INPUT_20\n   */\n  readonly tier?: RouterInputTier;\n  /** Configuration for the Router Input (standard, failover, merge, or MediaConnect flow) */\n  readonly configuration: RouterInputConfiguration;\n  /**\n   * Maintenance window configuration\n   * @default - Default maintenance window will be used\n   */\n  readonly maintenanceConfiguration?: MaintenanceConfiguration;\n  /**\n   * AWS region where the Router Input will be created (i.e. us-east-1).\n   *\n   * Must match the region of the flows, flow outputs, and network interfaces it connects to —\n   * MediaConnect rejects a cross-region connection at deploy.\n   *\n   * @default - Same as the stack's region\n   */\n  readonly regionName?: string;\n  /**\n   * Tags to add to the Router Input\n   * @default - No tagging\n   */\n  readonly tags?: { [key: string]: string };\n  /**\n   * Transit encryption configuration using AWS Secrets Manager.\n   *\n   * When provided without a role, a scoped IAM role is automatically created with read\n   * access to the secret.\n   *\n   * @default - Automatic encryption will be configured\n   */\n  readonly transitEncryption?: TransitEncryption;\n}\n\n/**\n * Attributes for importing an existing Router Input.\n */\nexport interface RouterInputAttributes {\n  /**\n   * The Amazon Resource Name (ARN) of the router input.\n   */\n  readonly routerInputArn: string;\n\n  /**\n   * The unique identifier of the router input.\n   *\n   * @default - accessing `routerInputId` on the imported input throws; only provide when available.\n   */\n  readonly routerInputId?: string;\n\n  /**\n   * The IP address that the router input uses to ingest content.\n   *\n   * @default - accessing `ipAddress` on the imported input throws; only provide when available.\n   */\n  readonly ipAddress?: string;\n}\n\n/**\n * Forward Error Correction (FEC) options for RTP protocol\n */\nexport enum ForwardErrorCorrection {\n  /** Enable Forward Error Correction */\n  ENABLED='ENABLED',\n  /** Disable Forward Error Correction */\n  DISABLED='DISABLED',\n}\n\n/**\n * Identifies which protocol in a failover configuration's protocols array is primary.\n */\nexport enum PrimarySource {\n  /** The first protocol in the failover protocols array. */\n  FIRST_SOURCE = 0,\n  /** The second protocol in the failover protocols array. */\n  SECOND_SOURCE = 1,\n}\n\n/**\n * Internal CFN-level values for the source priority mode.\n * @internal\n */\nenum SourcePriorityMode {\n  /** Both sources are equal priority — the service picks one. */\n  NO_PRIORITY = 'NO_PRIORITY',\n  /** One source is primary, the other is backup. */\n  PRIMARY_SECONDARY = 'PRIMARY_SECONDARY',\n}\n\n/**\n * Source priority configuration for failover Router Input configurations.\n */\nexport class SourcePriorityConfig {\n  /**\n   * Treat both sources with equal priority — MediaConnect picks one when needed.\n   */\n  public static none(): SourcePriorityConfig {\n    return new SourcePriorityConfig(SourcePriorityMode.NO_PRIORITY, undefined);\n  }\n\n  /**\n   * Designate one of the two sources as primary; the other is treated as backup.\n   */\n  public static primarySecondary(primary: PrimarySource): SourcePriorityConfig {\n    return new SourcePriorityConfig(SourcePriorityMode.PRIMARY_SECONDARY, primary);\n  }\n\n  private constructor(\n    private readonly _mode: SourcePriorityMode,\n    private readonly _primary: PrimarySource | undefined,\n  ) {}\n\n  /**\n   * Resolve the configuration to its CFN shape.\n   * @internal\n   */\n  public _bind(): { sourcePriorityMode: string; primarySourceIndex?: number } {\n    return {\n      sourcePriorityMode: this._mode,\n      primarySourceIndex: this._primary,\n    };\n  }\n}\n\n/**\n * Properties for RTP protocol configuration\n */\nexport interface RtpProtocolProps {\n  /** Port number for RTP traffic */\n  readonly port: number;\n  /**\n   * Forward Error Correction setting\n   * @default - undefined; when omitted, MediaConnect applies ForwardErrorCorrection.DISABLED at deploy time\n   */\n  readonly forwardErrorCorrection?: ForwardErrorCorrection;\n}\n\n/**\n * Properties for RIST protocol configuration\n */\nexport interface RistProtocolProps {\n  /** Port number for RIST traffic */\n  readonly port: number;\n  /** Recovery latency for RIST */\n  readonly recoveryLatency: Duration;\n}\n\n/**\n * Properties for SRT Listener protocol configuration\n */\nexport interface SrtListenerProtocolProps {\n  /** Port number for SRT listener */\n  readonly port: number;\n  /** Minimum latency for SRT */\n  readonly minimumLatency: Duration;\n  /**\n   * Optional decryption configuration for encrypted SRT streams\n   * @default - No decryption\n   */\n  readonly decryptionConfiguration?: RouterSrtEncryption;\n}\n\n/**\n * Properties for SRT Caller protocol configuration\n */\nexport interface SrtCallerProtocolProps {\n  /** Source IP address to connect to */\n  readonly sourceAddress: string;\n  /** Source port to connect to */\n  readonly sourcePort: number;\n  /** Minimum latency for SRT */\n  readonly minimumLatency: Duration;\n  /**\n   * Optional stream ID for SRT connection\n   * @default - No stream ID\n   */\n  readonly streamId?: string;\n  /**\n   * Optional decryption configuration for encrypted SRT streams\n   * @default - No decryption\n   */\n  readonly decryptionConfiguration?: RouterSrtEncryption;\n}\n\n/**\n * Identifies which configuration type a port conflict check is being performed for.\n * @internal\n */\nenum ProtocolConfigType {\n  /** Failover-mode router input configuration. */\n  FAILOVER = 'failover',\n  /** Merge-mode router input configuration. */\n  MERGE = 'merge',\n}\n\n/**\n * Factory class for creating Router Input protocol configurations\n */\nexport class RouterInputProtocol {\n  /**\n   * Create an RTP protocol configuration\n   * @param props RTP protocol properties\n   * @returns RouterInputProtocol instance configured for RTP\n   */\n  public static rtp(props: RtpProtocolProps): RouterInputProtocol {\n    RouterInputProtocol.validatePort(props.port);\n    return new RouterInputProtocol(RouterInputProtocolOptions.RTP, {\n      rtp: {\n        port: props.port,\n        forwardErrorCorrection: props.forwardErrorCorrection,\n      },\n    }, props.port);\n  }\n\n  /**\n   * Create a RIST protocol configuration\n   * @param props RIST protocol properties\n   * @returns RouterInputProtocol instance configured for RIST\n   */\n  public static rist(props: RistProtocolProps): RouterInputProtocol {\n    RouterInputProtocol.validatePort(props.port);\n    return new RouterInputProtocol(RouterInputProtocolOptions.RIST, {\n      rist: {\n        port: props.port,\n        recoveryLatencyMilliseconds: props.recoveryLatency.toMilliseconds(),\n      },\n    }, props.port);\n  }\n\n  /**\n   * Create an SRT Listener protocol configuration\n   * @param props SRT Listener protocol properties\n   * @returns RouterInputProtocol instance configured for SRT Listener\n   */\n  public static srtListener(props: SrtListenerProtocolProps): RouterInputProtocol {\n    RouterInputProtocol.validatePort(props.port);\n    return new RouterInputProtocol(RouterInputProtocolOptions.SRT_LISTENER, {\n      srtListener: {\n        port: props.port,\n        minimumLatencyMilliseconds: props.minimumLatency.toMilliseconds(),\n      },\n    }, props.port, props.decryptionConfiguration);\n  }\n\n  /**\n   * Create an SRT Caller protocol configuration\n   * @param props SRT Caller protocol properties\n   * @returns RouterInputProtocol instance configured for SRT Caller\n   */\n  public static srtCaller(props: SrtCallerProtocolProps): RouterInputProtocol {\n    RouterInputProtocol.validateSrtCallerPort(props.sourcePort);\n    return new RouterInputProtocol(RouterInputProtocolOptions.SRT_CALLER, {\n      srtCaller: {\n        sourceAddress: props.sourceAddress,\n        sourcePort: props.sourcePort,\n        minimumLatencyMilliseconds: props.minimumLatency.toMilliseconds(),\n        streamId: props.streamId,\n      },\n    }, undefined, props.decryptionConfiguration);\n  }\n\n  /**\n   * Validate that port is within the valid range (3000-30000)\n   */\n  private static validatePort(port: number): void {\n    if (!Token.isUnresolved(port) && (port < 3000 || port > 30000)) {\n      throw new UnscopedValidationError(lit`RouterInputPortRange`, `Port must be between 3000 and 30000, got ${port}`);\n    }\n  }\n\n  /**\n   * Validate that SRT Caller port is within the valid range (0-65535)\n   */\n  private static validateSrtCallerPort(port: number): void {\n    if (!Token.isUnresolved(port) && (port < 0 || port > 65535)) {\n      throw new UnscopedValidationError(lit`SrtCallerPortRange`, `SRT Caller port must be between 0 and 65535, got ${port}`);\n    }\n  }\n\n  private readonly _protocolName: RouterInputProtocolOptions;\n  private readonly _config: CfnRouterInput.RouterInputProtocolConfigurationProperty;\n  private readonly _port?: number;\n  private readonly _decryption?: RouterSrtEncryption;\n\n  private constructor(\n    protocolName: RouterInputProtocolOptions,\n    config: CfnRouterInput.RouterInputProtocolConfigurationProperty,\n    port?: number,\n    decryption?: RouterSrtEncryption,\n  ) {\n    this._protocolName = protocolName;\n    this._config = config;\n    this._port = port;\n    this._decryption = decryption;\n  }\n\n  /**\n   * Resolve this protocol to its CFN-ready form. Returns the protocol identifier,\n   * the CFN configuration shape (with SRT decryption auto-role materialized if needed),\n   * and the ingest port if the protocol has one.\n   *\n   * @param scope         Construct that scopes the auto-created decryption role\n   * @param routerInputArn  Optional ARN of the consuming router input — when provided,\n   *                        scopes the auto-created decryption role's trust policy.\n   *\n   * @internal\n   */\n  public _bind(scope: Construct, routerInputArn?: string): {\n    name: RouterInputProtocolOptions;\n    config: CfnRouterInput.RouterInputProtocolConfigurationProperty;\n    port?: number;\n  } {\n    if (!this._decryption) {\n      return { name: this._protocolName, config: this._config, port: this._port };\n    }\n\n    const decryptionConfiguration = renderRouterSrtEncryption(scope, 'DecryptionRole', this._decryption, routerInputArn);\n\n    if (this._config.srtListener) {\n      return {\n        name: this._protocolName,\n        port: this._port,\n        config: { srtListener: { ...this._config.srtListener, decryptionConfiguration } },\n      };\n    }\n    if (this._config.srtCaller) {\n      return {\n        name: this._protocolName,\n        port: this._port,\n        config: { srtCaller: { ...this._config.srtCaller, decryptionConfiguration } },\n      };\n    }\n    return { name: this._protocolName, config: this._config, port: this._port };\n  }\n\n  /**\n   * Compute the ingest URL (scheme://ipAddress:port) for this protocol, if it has\n   * a listening port.\n   *\n   * @internal\n   */\n  public _ingestUrl(ipAddress: string): string | undefined {\n    if (this._port === undefined) return undefined;\n    return renderIngestUrl(this._protocolName.value, this._port, ipAddress);\n  }\n\n  /**\n   * The listening port for this protocol, if it has one. Undefined for SRT caller\n   * (which has a `sourcePort` pointing at the upstream listener, not a port the input\n   * itself listens on).\n   *\n   * @internal\n   */\n  public _listeningPort(): number | undefined {\n    return this._port;\n  }\n\n  /**\n   * Whether two protocols share the same protocol identifier.\n   *\n   * @internal\n   */\n  public _matchesKind(other: RouterInputProtocol): boolean {\n    return this._protocolName.value === other._protocolName.value;\n  }\n\n  /**\n   * Whether this protocol is SRT (Caller or Listener).\n   *\n   * @internal\n   */\n  public _isSrt(): boolean {\n    return this._protocolName.value === RouterInputProtocolOptions.SRT_CALLER.value\n      || this._protocolName.value === RouterInputProtocolOptions.SRT_LISTENER.value;\n  }\n\n  /**\n   * Validate port compatibility between this protocol and another in a failover or\n   * merge configuration. Throws on conflicts appropriate to the protocol kind.\n   *\n   * @internal\n   */\n  public _validatePortConflicts(other: RouterInputProtocol, configType: ProtocolConfigType): void {\n    const protocolValue = this._protocolName.value;\n\n    if (protocolValue === RouterInputProtocolOptions.RIST.value) {\n      const rist1 = this._config.rist;\n      const rist2 = other._config.rist;\n      if (rist1 && rist2 && 'port' in rist1 && 'port' in rist2) {\n        const port1 = rist1.port;\n        const port2 = rist2.port;\n        if (port1 === port2) {\n          throw new UnscopedValidationError(\n            lit`DuplicateRistPort`,\n            `${configType} configuration cannot use the same RIST port ${port1} for both protocols, ` +\n            'each protocol must use a different port number',\n          );\n        }\n        if (Math.abs(port1 - port2) < 2) {\n          throw new UnscopedValidationError(\n            lit`ConsecutiveRistPort`,\n            `${configType} configuration cannot use consecutive RIST ports ${Math.min(port1, port2)} and ${Math.max(port1, port2)}, ` +\n            'RIST protocols require non-consecutive ports to avoid overlapping ranges (e.g., use 6000 and 6002)',\n          );\n        }\n      }\n      return;\n    }\n\n    if (protocolValue === RouterInputProtocolOptions.RTP.value) {\n      const rtp1 = this._config.rtp;\n      const rtp2 = other._config.rtp;\n      if (rtp1 && rtp2 && 'port' in rtp1 && 'port' in rtp2 && rtp1.port === rtp2.port) {\n        throw new UnscopedValidationError(\n          lit`DuplicateRtpPort`,\n          `${configType} configuration cannot use the same RTP port ${rtp1.port} for both protocols, ` +\n          'each protocol must use a different port number',\n        );\n      }\n      return;\n    }\n\n    if (protocolValue === RouterInputProtocolOptions.SRT_LISTENER.value) {\n      const srt1 = this._config.srtListener;\n      const srt2 = other._config.srtListener;\n      if (srt1 && srt2 && 'port' in srt1 && 'port' in srt2 && srt1.port === srt2.port) {\n        throw new UnscopedValidationError(\n          lit`DuplicateSrtListenerPort`,\n          `${configType} configuration cannot use the same SRT Listener port ${srt1.port} for both protocols, ` +\n          'each protocol must use a different port number',\n        );\n      }\n    }\n  }\n}\n\n/**\n * Properties for standard Router Input configuration\n */\nexport interface StandardConfigurationProps {\n  /** Network interface for the Router Input */\n  readonly networkInterface: IRouterNetworkInterface;\n  /** Protocol configuration for the input */\n  readonly protocol: RouterInputProtocol;\n}\n\n/**\n * Properties for failover Router Input configuration\n */\nexport interface FailoverConfigurationProps {\n  /** Network interface for the Router Input */\n  readonly networkInterface: IRouterNetworkInterface;\n  /** Array of exactly 2 protocol configurations for failover (must be same protocol type) */\n  readonly protocols: RouterInputProtocol[];\n  /**\n   * Source priority configuration for failover.\n   *\n   * @default SourcePriorityConfig.none()\n   */\n  readonly sourcePriority?: SourcePriorityConfig;\n}\n\n/**\n * Properties for merge Router Input configuration\n */\nexport interface MergeConfigurationProps {\n  /** Network interface for the Router Input */\n  readonly networkInterface: IRouterNetworkInterface;\n  /** Array of exactly 2 protocol configurations for merge (must be same non-SRT protocol type) */\n  readonly protocols: RouterInputProtocol[];\n  /** Recovery window for merge operation */\n  readonly mergeRecoveryWindow: Duration;\n}\n\n/**\n * Properties for MediaConnect Flow Router Input configuration\n */\nexport interface MediaConnectFlowConfigurationProps {\n  /** The MediaConnect flow to use as input */\n  readonly flow: IFlow;\n  /** The flow output that feeds this router input */\n  readonly flowOutput: IFlowOutput;\n  /**\n   * Optional transit encryption configuration\n   * @default - Automatic encryption will be used\n   */\n  readonly sourceTransitDecryption?: TransitEncryption;\n}\n\n/**\n * Properties for MediaConnect Flow Router Input configuration - without a connection\n */\nexport interface MediaConnectFlowConfigurationWithoutConnectionProps {\n  /**\n   * Availability Zone the router input will be placed in.\n   */\n  readonly availabilityZone: string;\n  /**\n   * Optional transit encryption configuration\n   * @default - Automatic encryption will be used\n   */\n  readonly sourceTransitDecryption?: TransitEncryption;\n}\n\n/**\n * Properties for MediaLive Channel Router Input configuration.\n *\n * Use this when the MediaLive channel already exists and you want to ingest\n * from one of its outputs immediately.\n */\nexport interface MediaLiveChannelConfigurationProps {\n  /**\n   * ARN of the MediaLive channel to use as input.\n   *\n   * Note: This will change to accept a typed MediaLive channel reference\n   * when the @aws-cdk/aws-medialive-alpha L2 construct is released.\n   */\n  readonly mediaLiveChannelArn: string;\n\n  /**\n   * The name of the MediaLive channel output to connect to this router input.\n   */\n  readonly mediaLiveChannelOutputName: string;\n\n  /**\n   * The MediaLive pipeline to connect to this router input.\n   */\n  readonly mediaLivePipelineId: MediaLivePipeline;\n\n  /**\n   * Optional transit encryption configuration.\n   *\n   * @default - Automatic encryption will be used\n   */\n  readonly sourceTransitDecryption?: TransitEncryption;\n}\n\n/**\n * Properties for MediaLive Channel Router Input configuration without a specific channel connection.\n *\n * Use this when you want to set up the router input before the target MediaLive channel exists.\n */\nexport interface MediaLiveChannelConfigurationWithoutConnectionProps {\n  /**\n   * Availability Zone the router input will be placed in.\n   */\n  readonly availabilityZone: string;\n\n  /**\n   * Optional transit encryption configuration.\n   *\n   * @default - Automatic encryption will be used\n   */\n  readonly sourceTransitDecryption?: TransitEncryption;\n}\n\n/**\n * Factory class for creating Router Input configurations\n */\nexport abstract class RouterInputConfiguration {\n  /**\n   * Create a standard Router Input configuration with a single protocol\n   * @param props Standard configuration properties\n   * @returns RouterInputConfiguration instance for standard setup\n   */\n  public static standard(props: StandardConfigurationProps): RouterInputConfiguration {\n    return new StandardRouterInputConfig(props);\n  }\n\n  /**\n   * Create a failover Router Input configuration with two matching protocols\n   * @param props Failover configuration properties\n   * @returns RouterInputConfiguration instance for failover setup\n   * @throws Error if protocols don't match or count is not exactly 2\n   */\n  public static failover(props: FailoverConfigurationProps): RouterInputConfiguration {\n    if (!Token.isUnresolved(props.protocols) && props.protocols.length !== 2) {\n      throw new UnscopedValidationError(lit`FailoverProtocolCount`, `Failover configuration requires exactly 2 protocols, got ${props.protocols.length}`);\n    }\n    if (!props.protocols[0]._matchesKind(props.protocols[1])) {\n      throw new UnscopedValidationError(lit`FailoverProtocolMismatch`, 'Protocols must match');\n    }\n    props.protocols[0]._validatePortConflicts(props.protocols[1], ProtocolConfigType.FAILOVER);\n    return new FailoverRouterInputConfig(props);\n  }\n\n  /**\n   * Create a merge Router Input configuration with two matching non-SRT protocols\n   * @param props Merge configuration properties\n   * @returns RouterInputConfiguration instance for merge setup\n   * @throws Error if protocols don't match, count is not exactly 2, or SRT protocols are used\n   */\n  public static merge(props: MergeConfigurationProps): RouterInputConfiguration {\n    if (!Token.isUnresolved(props.protocols) && props.protocols.length !== 2) {\n      throw new UnscopedValidationError(lit`MergeProtocolCount`, `Merge configuration requires exactly 2 protocols, got ${props.protocols.length}`);\n    }\n    if (props.protocols.some(p => p._isSrt())) {\n      throw new UnscopedValidationError(lit`MergeSrtNotSupported`, 'SRT protocols are not supported in merge configuration');\n    }\n    if (!props.protocols[0]._matchesKind(props.protocols[1])) {\n      throw new UnscopedValidationError(lit`MergeProtocolMismatch`, 'Protocols must match');\n    }\n    props.protocols[0]._validatePortConflicts(props.protocols[1], ProtocolConfigType.MERGE);\n    return new MergeRouterInputConfig(props);\n  }\n\n  /**\n   * Create a MediaConnect Flow Router Input configuration without connecting to a specific flow\n   * Use this when you want to prepare the router input for a flow connection later\n   * @param props MediaConnect Flow configuration properties without connection\n   * @returns RouterInputConfiguration instance for MediaConnect Flow setup without connection\n   */\n  public static mediaConnectFlowWithoutConnection(props: MediaConnectFlowConfigurationWithoutConnectionProps): RouterInputConfiguration {\n    return new MediaConnectFlowRouterInputConfig({ sourceTransitDecryption: props.sourceTransitDecryption }, props.availabilityZone);\n  }\n\n  /**\n   * Create a MediaConnect Flow Router Input configuration.\n   *\n   * Use this when the source flow already exists and you want to connect immediately.\n   *\n   * @param props MediaConnect Flow configuration properties\n   * @returns RouterInputConfiguration instance for MediaConnect Flow setup\n   */\n  public static mediaConnectFlow(props: MediaConnectFlowConfigurationProps): RouterInputConfiguration {\n    return new MediaConnectFlowRouterInputConfig({\n      flow: props.flow,\n      flowOutput: props.flowOutput,\n      sourceTransitDecryption: props.sourceTransitDecryption,\n    });\n  }\n\n  /**\n   * Create a MediaLive Channel Router Input configuration.\n   *\n   * Use this when the source MediaLive channel already exists and you want to\n   * ingest from one of its outputs immediately.\n   *\n   * @param props MediaLive channel configuration properties\n   * @returns RouterInputConfiguration instance for MediaLive channel setup\n   */\n  public static mediaLiveChannel(props: MediaLiveChannelConfigurationProps): RouterInputConfiguration {\n    return new MediaLiveChannelRouterInputConfig({\n      mediaLiveChannelArn: props.mediaLiveChannelArn,\n      mediaLiveChannelOutputName: props.mediaLiveChannelOutputName,\n      mediaLivePipelineId: props.mediaLivePipelineId,\n      sourceTransitDecryption: props.sourceTransitDecryption,\n    });\n  }\n\n  /**\n   * Create a MediaLive Channel Router Input configuration without a specific channel connection.\n   *\n   * Use this when you want to set up the router input before the target MediaLive channel exists.\n   *\n   * @param props MediaLive channel no-connection properties\n   * @returns RouterInputConfiguration instance for MediaLive channel setup without connection\n   */\n  public static mediaLiveChannelWithoutConnection(props: MediaLiveChannelConfigurationWithoutConnectionProps): RouterInputConfiguration {\n    return new MediaLiveChannelRouterInputConfig({ sourceTransitDecryption: props.sourceTransitDecryption }, props.availabilityZone);\n  }\n\n  /**\n   * Resolve this configuration to its CloudFormation shape. Called by the RouterInput\n   * constructor — each concrete subclass supplies its own variant-specific rendering.\n   * @internal\n   */\n  public abstract _bind(scope: Construct, routerInputArn?: string): {\n    config: CfnRouterInput.RouterInputConfigurationProperty; availabilityZone?: string;\n  };\n\n  /**\n   * Compute the ingest endpoints for protocol-based inputs that listen on one or more\n   * ports.\n   *\n   * Returns `undefined` when the variant has no concept of a listen port (SRT caller,\n   * MediaConnect Flow, MediaLive Channel). Returns an array with one entry for\n   * standard variants, and one entry per source for failover and merge.\n   * @internal\n   */\n  public abstract _endpoints(ipAddress: string): RouterInputEndpoint[] | undefined;\n}\n\n/**\n * Render an ingest URL string (scheme://ip:port). Used by `_ingestUrl()` on individual\n * protocols and composed into the per-config-variant `_endpoints()` results.\n *\n * Extracts the base protocol for the URL scheme (e.g. SRT_LISTENER → srt, RTP → rtp).\n */\nfunction renderIngestUrl(protocolName: string, port: number, ipAddress: string): string {\n  const scheme = protocolName.toLowerCase().split('_')[0];\n  return Fn.join('', [`${scheme}://`, ipAddress, `:${port}`]);\n}\n\n/**\n * Concrete variant: standard (single-protocol) router input configuration.\n * @internal\n */\nclass StandardRouterInputConfig extends RouterInputConfiguration {\n  constructor(private readonly props: StandardConfigurationProps) { super(); }\n\n  public _bind(scope: Construct, routerInputArn?: string) {\n    const protocol = this.props.protocol._bind(scope, routerInputArn);\n    return {\n      config: {\n        standard: {\n          networkInterfaceArn: this.props.networkInterface.routerNetworkInterfaceArn,\n          protocol: protocol.name.value,\n          protocolConfiguration: protocol.config,\n        },\n      },\n    };\n  }\n\n  public _endpoints(ipAddress: string): RouterInputEndpoint[] | undefined {\n    const url = this.props.protocol._ingestUrl(ipAddress);\n    const port = this.props.protocol._listeningPort();\n    if (url === undefined || port === undefined) return undefined;\n    return [{ url, port }];\n  }\n}\n\n/**\n * Concrete variant: failover router input configuration.\n * @internal\n */\nclass FailoverRouterInputConfig extends RouterInputConfiguration {\n  constructor(private readonly props: FailoverConfigurationProps) { super(); }\n\n  public _bind(scope: Construct, routerInputArn?: string) {\n    const priority = (this.props.sourcePriority ?? SourcePriorityConfig.none())._bind();\n    return {\n      config: {\n        failover: {\n          networkInterfaceArn: this.props.networkInterface.routerNetworkInterfaceArn,\n          protocolConfigurations: this.props.protocols.map(p => p._bind(scope, routerInputArn).config),\n          sourcePriorityMode: priority.sourcePriorityMode,\n          primarySourceIndex: priority.primarySourceIndex,\n        },\n      },\n    };\n  }\n\n  public _endpoints(ipAddress: string): RouterInputEndpoint[] | undefined {\n    const endpoints: RouterInputEndpoint[] = [];\n    for (const p of this.props.protocols) {\n      const url = p._ingestUrl(ipAddress);\n      const port = p._listeningPort();\n      if (url === undefined || port === undefined) return undefined;\n      endpoints.push({ url, port });\n    }\n    return endpoints;\n  }\n}\n\n/**\n * Concrete variant: merge router input configuration.\n * @internal\n */\nclass MergeRouterInputConfig extends RouterInputConfiguration {\n  constructor(private readonly props: MergeConfigurationProps) { super(); }\n\n  public _bind(scope: Construct, routerInputArn?: string) {\n    return {\n      config: {\n        merge: {\n          networkInterfaceArn: this.props.networkInterface.routerNetworkInterfaceArn,\n          protocolConfigurations: this.props.protocols.map(p => p._bind(scope, routerInputArn).config),\n          mergeRecoveryWindowMilliseconds: this.props.mergeRecoveryWindow.toMilliseconds(),\n        },\n      },\n    };\n  }\n\n  public _endpoints(ipAddress: string): RouterInputEndpoint[] | undefined {\n    const endpoints: RouterInputEndpoint[] = [];\n    for (const p of this.props.protocols) {\n      const url = p._ingestUrl(ipAddress);\n      const port = p._listeningPort();\n      if (url === undefined || port === undefined) return undefined;\n      endpoints.push({ url, port });\n    }\n    return endpoints;\n  }\n}\n\n/**\n * Internal options for {@link MediaConnectFlowRouterInputConfig}. Not exported; jsii never sees this.\n */\ninterface MediaConnectFlowRouterInputOptions {\n  readonly flow?: IFlow;\n  readonly flowOutput?: IFlowOutput;\n  readonly sourceTransitDecryption?: TransitEncryption;\n}\n\n/**\n * Concrete variant: MediaConnect Flow router input configuration (with or without connection).\n * @internal\n */\nclass MediaConnectFlowRouterInputConfig extends RouterInputConfiguration {\n  constructor(\n    private readonly options: MediaConnectFlowRouterInputOptions,\n    private readonly availabilityZone?: string,\n  ) { super(); }\n\n  public _bind(scope: Construct, routerInputArn?: string) {\n    return {\n      config: {\n        mediaConnectFlow: {\n          flowArn: this.options.flow?.flowArn,\n          flowOutputArn: this.options.flowOutput?.flowOutputArn,\n          sourceTransitDecryption: renderTransitEncryption(scope, 'SourceTransitDecryptionRole', this.options.sourceTransitDecryption, routerInputArn),\n        },\n      },\n      availabilityZone: this.availabilityZone,\n    };\n  }\n\n  public _endpoints(_ipAddress: string): RouterInputEndpoint[] | undefined {\n    return undefined;\n  }\n}\n\n/**\n * Internal options for {@link MediaLiveChannelRouterInputConfig}. Not exported; jsii never sees this.\n */\ninterface MediaLiveChannelRouterInputOptions {\n  readonly mediaLiveChannelArn?: string;\n  readonly mediaLiveChannelOutputName?: string;\n  readonly mediaLivePipelineId?: MediaLivePipeline;\n  readonly sourceTransitDecryption?: TransitEncryption;\n}\n\n/**\n * Concrete variant: MediaLive Channel router input configuration (with or without connection).\n * @internal\n */\nclass MediaLiveChannelRouterInputConfig extends RouterInputConfiguration {\n  constructor(\n    private readonly options: MediaLiveChannelRouterInputOptions,\n    private readonly availabilityZone?: string,\n  ) { super(); }\n\n  public _bind(scope: Construct, routerInputArn?: string) {\n    return {\n      config: {\n        mediaLiveChannel: {\n          mediaLiveChannelArn: this.options.mediaLiveChannelArn,\n          mediaLiveChannelOutputName: this.options.mediaLiveChannelOutputName,\n          mediaLivePipelineId: this.options.mediaLivePipelineId,\n          sourceTransitDecryption: renderTransitEncryption(scope, 'SourceTransitDecryptionRole', this.options.sourceTransitDecryption, routerInputArn),\n        },\n      },\n      availabilityZone: this.availabilityZone,\n    };\n  }\n\n  public _endpoints(_ipAddress: string): RouterInputEndpoint[] | undefined {\n    return undefined;\n  }\n}\n\n/**\n * A MediaConnect Router Input that receives media streams and routes them to outputs.\n *\n * Router Inputs support multiple configuration types:\n * - Standard: Single protocol input\n * - Failover: Two matching protocols for redundancy\n * - Merge: Two matching non-SRT protocols for stream merging\n * - MediaConnect Flow: Input from an existing MediaConnect Flow\n */\nabstract class RouterInputBase extends Resource implements IRouterInput {\n  public abstract readonly routerInputArn: string;\n  public abstract readonly routerInputId: string;\n  public abstract readonly ipAddress: string;\n  public abstract readonly createdAt?: string;\n  public abstract readonly updatedAt?: string;\n  public abstract readonly endpoints: RouterInputEndpoint[];\n  public abstract readonly transitEncryptionSecret?: ISecret;\n  public abstract readonly grants: RouterInputGrants;\n\n  /**\n   * A reference to this Router Input resource.\n   * Required by the auto-generated IRouterInputRef interface.\n   */\n  public get routerInputRef(): RouterInputReference {\n    return { routerInputArn: this.routerInputArn };\n  }\n\n  /**\n   * Create a CloudWatch metric for this router input.\n   */\n  public metric(metricName: string, props?: MetricOptions): Metric {\n    return new Metric({\n      metricName,\n      namespace: 'AWS/MediaConnect',\n      ...props,\n      dimensionsMap: {\n        RouterInputARN: this.routerInputArn,\n        ...props?.dimensionsMap,\n      },\n    }).attachTo(this);\n  }\n\n  /**\n   * Metric for the bitrate of the router input's payload.\n   */\n  public metricBitrate(props?: MetricOptions): Metric {\n    return this.metric('RouterInputBitRate', {\n      statistic: 'avg',\n      period: Duration.seconds(60),\n      unit: Unit.BITS_PER_SECOND,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for packets lost in transit that were not recovered by error correction.\n   */\n  public metricNotRecoveredPackets(props?: MetricOptions): Metric {\n    return this.metric('RouterInputNotRecoveredPackets', {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.COUNT,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the total number of packets received by the router input.\n   */\n  public metricTotalPackets(props?: MetricOptions): Metric {\n    return this.metric('RouterInputTotalPackets', {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.COUNT,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the router input connection state (1 connected, 0 disconnected). Applies to SRT sources only.\n   */\n  public metricConnected(props?: MetricOptions): Metric {\n    return this.metric('RouterInputConnected', {\n      statistic: 'min',\n      period: Duration.seconds(60),\n      unit: Unit.NONE,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for continuity counter errors in the transport stream.\n   */\n  public metricContinuityCounterErrors(props?: MetricOptions): Metric {\n    return this.metric('RouterInputCCErrors', {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.COUNT,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the recovery latency of the input stream. Applies to RIST, SRT, and RTP-FEC.\n   */\n  public metricLatency(props?: MetricOptions): Metric {\n    return this.metric('RouterInputLatency', {\n      statistic: 'avg',\n      period: Duration.seconds(60),\n      unit: Unit.MILLISECONDS,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the number of times the router input has switched sources in Failover mode.\n   */\n  public metricFailoverSwitches(props?: MetricOptions): Metric {\n    return this.metric('RouterInputFailoverSwitches', {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.COUNT,\n      ...props,\n    });\n  }\n}\n\n/**\n * Defines an AWS Elemental MediaConnect Router Input.\n */\n@propertyInjectable\nexport class RouterInput extends RouterInputBase implements IRouterInput {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-mediaconnect-alpha.RouterInput';\n\n  /**\n   * Import an existing Router Input from its ARN.\n   *\n   * Use `fromRouterInputAttributes()` instead if you need to expose `routerInputId`\n   * or `ipAddress` on the imported construct.\n   *\n   * @param scope The parent construct\n   * @param id The construct id\n   * @param routerInputArn The ARN of the Router Input\n   * @returns A Router Input construct\n   */\n  public static fromRouterInputArn(scope: Construct, id: string, routerInputArn: string): IRouterInput {\n    return RouterInput.fromRouterInputAttributes(scope, id, { routerInputArn });\n  }\n\n  /**\n   * Import an existing Router Input from its attributes.\n   *\n   * Provide `routerInputId` and/or `ipAddress` when importing an input that was deployed\n   * externally — otherwise accessing those properties on the imported construct will throw.\n   *\n   * @param scope The parent construct\n   * @param id The construct id\n   * @param attrs The Router Input attributes\n   * @returns A Router Input construct\n   */\n  public static fromRouterInputAttributes(scope: Construct, id: string, attrs: RouterInputAttributes): IRouterInput {\n    class Import extends RouterInputBase implements IRouterInput {\n      public readonly routerInputArn = attrs.routerInputArn;\n      public readonly createdAt = undefined;\n      public readonly updatedAt = undefined;\n      public readonly transitEncryptionSecret = undefined;\n      public readonly grants = RouterInputGrants.fromRouterInput(this);\n\n      public get endpoints(): RouterInputEndpoint[] {\n        throw new ValidationError(\n          lit`RouterInputEndpointsNotAvailableImported`,\n          `'endpoints' is not available on imported RouterInput ${this.node.path}; only RouterInputs constructed in this app for listening protocol variants (RTP, RIST, SRT listener, including failover and merge) expose ingest endpoints`,\n          this,\n        );\n      }\n\n      public get routerInputId(): string {\n        if (attrs.routerInputId) return attrs.routerInputId;\n        throw new ValidationError(\n          lit`RouterInputIdNotProvided`,\n          `'routerInputId' is not available on imported RouterInput ${this.node.path}; pass it via fromRouterInputAttributes`,\n          this,\n        );\n      }\n\n      public get ipAddress(): string {\n        if (attrs.ipAddress) return attrs.ipAddress;\n        throw new ValidationError(\n          lit`RouterInputIpAddressNotProvided`,\n          `'ipAddress' is not available on imported RouterInput ${this.node.path}; pass it via fromRouterInputAttributes`,\n          this,\n        );\n      }\n    }\n    return new Import(scope, id);\n  }\n\n  /**\n   * Returns the maximum bitrate in Mbps for a known tier, or undefined for custom tiers.\n   */\n  private static tierLimitMbps(tier: RouterInputTier): number | undefined {\n    if (tier.value === RouterInputTier.INPUT_20.value) return 20;\n    if (tier.value === RouterInputTier.INPUT_50.value) return 50;\n    if (tier.value === RouterInputTier.INPUT_100.value) return 100;\n    return undefined;\n  }\n\n  public readonly routerInputArn: string;\n  public readonly routerInputId: string;\n  public readonly ipAddress: string;\n  public readonly createdAt?: string;\n  public readonly updatedAt?: string;\n  private readonly _endpoints: RouterInputEndpoint[] | undefined;\n  public readonly transitEncryptionSecret?: ISecret;\n  public readonly grants: RouterInputGrants;\n\n  public get endpoints(): RouterInputEndpoint[] {\n    if (this._endpoints === undefined) {\n      throw new ValidationError(\n        lit`RouterInputEndpointsNotAvailableConfig`,\n        `'endpoints' is not available on this RouterInput ${this.node.path}; only listening protocol variants (RTP, RIST, SRT listener — including failover and merge built from those) expose ingest endpoints — SRT caller, MediaConnect Flow, and MediaLive Channel inputs do not`,\n        this,\n      );\n    }\n    return this._endpoints;\n  }\n\n  constructor(scope: Construct, id: string, props: RouterInputProps) {\n    super(scope, id, {\n      physicalName: props.routerInputName ?? Lazy.string({ produce: () => Names.uniqueResourceName(this, { maxLength: 128 }) }),\n    });\n\n    // Validate router input name if provided\n    if (props.routerInputName != null && props.routerInputName !== '' && !Token.isUnresolved(props.routerInputName)) {\n      if (props.routerInputName.length > 128) {\n        throw new ValidationError(lit`RouterInputNameLength`, `Router input name must be between 1 and 128 characters, got ${props.routerInputName.length}`, this);\n      }\n      if (!/^[a-zA-Z0-9-]+$/.test(props.routerInputName)) {\n        throw new ValidationError(lit`RouterInputNameFormat`, `Router input name must contain only alphanumeric characters and hyphens, got '${props.routerInputName}'`, this);\n      }\n    }\n\n    // Validate maximum bitrate\n    if (!props.maximumBitrate.isUnresolved() && props.maximumBitrate.toBps() < 1000000) {\n      throw new ValidationError(lit`RouterInputMinBitrate`, `Maximum bitrate must be at least 1,000,000 bits/s (1 Mbps), got ${props.maximumBitrate.toBps()}`, this);\n    }\n\n    // Validate bitrate does not exceed tier limit\n    const resolvedTier = props.tier ?? RouterInputTier.INPUT_20;\n    const tierMbps = RouterInput.tierLimitMbps(resolvedTier);\n    if (exceedsRouterTierBitrate(tierMbps, props.maximumBitrate)) {\n      throw new ValidationError(lit`RouterInputBitrateExceedsTier`, `Maximum bitrate ${props.maximumBitrate.toBps() / 1_000_000} Mbps exceeds the ${resolvedTier.value} tier limit of ${tierMbps} Mbps`, this);\n    }\n\n    // Validate maintenance time format\n    if (props.maintenanceConfiguration) {\n      validateMaintenanceTime(props.maintenanceConfiguration.time);\n    }\n\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    const stack = Stack.of(this);\n    const targetRegion = props.regionName ?? stack.region;\n\n    // Wildcard the id — pinning the live ARN (attrArn) would create a role → router-input → role cycle.\n    const routerInputArn = stack.formatArn({\n      service: 'mediaconnect',\n      region: targetRegion,\n      resource: 'routerInput',\n      resourceName: '*',\n      arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n    });\n\n    const configBind = props.configuration._bind(this, routerInputArn);\n\n    // Validate AZ matches region if provided\n    if (configBind.availabilityZone && !configBind.availabilityZone.startsWith(targetRegion)) {\n      throw new ValidationError(lit`RouterInputAzRegionMismatch`, `Availability zone '${configBind.availabilityZone}' must be within region '${targetRegion}'`, this);\n    }\n\n    const transit = resolveTransitEncryption(this, 'TransitEncryptionRole', props.transitEncryption, routerInputArn);\n\n    const routerinput = new CfnRouterInput(this, 'Resource', {\n      name: this.physicalName,\n      maximumBitrate: props.maximumBitrate.toBps(),\n      tier: (props.tier ?? RouterInputTier.INPUT_20).value,\n      routingScope: props.routingScope.value,\n      maintenanceConfiguration: props.maintenanceConfiguration ? {\n        preferredDayTime: props.maintenanceConfiguration,\n      } : {\n        default: {},\n      },\n      configuration: configBind.config,\n      transitEncryption: transit.config,\n      regionName: targetRegion,\n      availabilityZone: configBind.availabilityZone,\n      tags: props.tags ? renderTags(props.tags) : undefined,\n    });\n\n    this.routerInputArn = routerinput.attrArn;\n    this.routerInputId = routerinput.attrId;\n    this.ipAddress = routerinput.attrIpAddress;\n    this.createdAt = routerinput.attrCreatedAt;\n    this.updatedAt = routerinput.attrUpdatedAt;\n\n    // Without this the router input can be created before the\n    // policy is attached (\"access denied\" at create time). Ordering the grant before the\n    // router input pulls the policy in as a dependency.\n    transit.grant?.applyBefore(routerinput);\n\n    // Compute ingest endpoints for protocol-based variants\n    this._endpoints = props.configuration._endpoints(routerinput.attrIpAddress);\n\n    // Store the transit encryption secret if explicitly provided\n    this.transitEncryptionSecret = props.transitEncryption?.secret;\n    this.grants = RouterInputGrants.fromRouterInput(this);\n  }\n}\n\n"]}