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

package/lib/router-output.js

@@ -0,0 +1,789 @@
+"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.RouterOutput = exports.RouterOutputConfiguration = exports.RouterOutputProtocol = exports.RouterOutputTier = exports.RouterOutputProtocolOptions = 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 shared_1 = require("./shared");
+/**
+ * Protocol options available for Router Output configurations
+ */
+class RouterOutputProtocolOptions {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.RouterOutputProtocolOptions", version: "2.263.0-alpha.0" };
+    /** Real-time Transport Protocol */
+    static RTP = new RouterOutputProtocolOptions('RTP');
+    /** Reliable Internet Stream Transport */
+    static RIST = new RouterOutputProtocolOptions('RIST');
+    /** Secure Reliable Transport - Caller mode */
+    static SRT_CALLER = new RouterOutputProtocolOptions('SRT_CALLER');
+    /** Secure Reliable Transport - Listener mode */
+    static SRT_LISTENER = new RouterOutputProtocolOptions('SRT_LISTENER');
+    /**
+     * Use a custom protocol value
+     * @param value The protocol string value
+     */
+    static of(value) {
+        return new RouterOutputProtocolOptions(value);
+    }
+    /** @param value The protocol string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.RouterOutputProtocolOptions = RouterOutputProtocolOptions;
+/**
+ * Routing tier that determines the maximum bitrate (in Mbps) for a Router Output.
+ */
+class RouterOutputTier {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.RouterOutputTier", version: "2.263.0-alpha.0" };
+    /** Up to 100 Mbps */
+    static OUTPUT_100 = new RouterOutputTier('OUTPUT_100');
+    /** Up to 50 Mbps */
+    static OUTPUT_50 = new RouterOutputTier('OUTPUT_50');
+    /** Up to 20 Mbps */
+    static OUTPUT_20 = new RouterOutputTier('OUTPUT_20');
+    /**
+     * Use a custom tier value
+     * @param value The tier string value
+     */
+    static of(value) {
+        return new RouterOutputTier(value);
+    }
+    /** @param value The tier string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.RouterOutputTier = RouterOutputTier;
+/**
+ * Factory class for creating Router Output protocol configurations.
+ *
+ * Supported protocols: RTP, RIST, SRT (Listener and Caller).
+ */
+class RouterOutputProtocol {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.RouterOutputProtocol", version: "2.263.0-alpha.0" };
+    /**
+     * Create an RTP protocol configuration
+     *
+     * @example
+     *
+     *    RouterOutputProtocol.rtp({
+     *      destinationAddress: '10.0.0.1',
+     *      port: 5000,
+     *    });
+     *
+     * @param props RTP protocol properties
+     * @returns RouterOutputProtocol instance configured for RTP
+     */
+    static rtp(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_RtpOutputProtocolProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rtp);
+            }
+            throw error;
+        }
+        RouterOutputProtocol.validatePort(props.port);
+        return new RouterOutputProtocol(RouterOutputProtocolOptions.RTP, {
+            rtp: {
+                destinationAddress: props.destinationAddress,
+                destinationPort: props.port,
+                forwardErrorCorrection: props.forwardErrorCorrection,
+            },
+        });
+    }
+    /**
+     * Create a RIST protocol configuration
+     *
+     * @example
+     *
+     *    RouterOutputProtocol.rist({
+     *      destinationAddress: '10.0.0.1',
+     *      port: 5000,
+     *    });
+     *
+     * @param props RIST protocol properties
+     * @returns RouterOutputProtocol instance configured for RIST
+     */
+    static rist(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_RistOutputProtocolProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rist);
+            }
+            throw error;
+        }
+        RouterOutputProtocol.validatePort(props.port);
+        return new RouterOutputProtocol(RouterOutputProtocolOptions.RIST, {
+            rist: {
+                destinationAddress: props.destinationAddress,
+                destinationPort: props.port,
+            },
+        });
+    }
+    /**
+     * Create an SRT Listener protocol configuration
+     *
+     * @example
+     *
+     *    RouterOutputProtocol.srtListener({
+     *      port: 5000,
+     *      minimumLatency: Duration.millis(125),
+     *    });
+     *
+     * @param props SRT Listener protocol properties
+     * @returns RouterOutputProtocol instance configured for SRT Listener
+     */
+    static srtListener(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SrtListenerOutputProtocolProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.srtListener);
+            }
+            throw error;
+        }
+        RouterOutputProtocol.validatePort(props.port);
+        return new RouterOutputProtocol(RouterOutputProtocolOptions.SRT_LISTENER, {
+            srtListener: {
+                port: props.port,
+                minimumLatencyMilliseconds: props.minimumLatency.toMilliseconds(),
+            },
+        }, props.encryptionConfiguration);
+    }
+    /**
+     * Create an SRT Caller protocol configuration
+     *
+     * @example
+     *
+     *    RouterOutputProtocol.srtCaller({
+     *      destinationAddress: '10.0.0.1',
+     *      destinationPort: 5000,
+     *      minimumLatency: Duration.millis(125),
+     *    });
+     *
+     * @param props SRT Caller protocol properties
+     * @returns RouterOutputProtocol instance configured for SRT Caller
+     */
+    static srtCaller(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SrtCallerOutputProtocolProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.srtCaller);
+            }
+            throw error;
+        }
+        RouterOutputProtocol.validateSrtCallerPort(props.destinationPort);
+        return new RouterOutputProtocol(RouterOutputProtocolOptions.SRT_CALLER, {
+            srtCaller: {
+                destinationAddress: props.destinationAddress,
+                destinationPort: props.destinationPort,
+                minimumLatencyMilliseconds: props.minimumLatency.toMilliseconds(),
+                streamId: props.streamId,
+            },
+        }, props.encryptionConfiguration);
+    }
+    /**
+     * 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) `RouterOutputPortRange`, `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;
+    _encryption;
+    constructor(protocolName, config, encryption) {
+        this._protocolName = protocolName;
+        this._config = config;
+        this._encryption = encryption;
+    }
+    /**
+     * Resolve this protocol to its CFN-ready form. Returns the protocol identifier
+     * and the CFN configuration shape with SRT encryption auto-role materialized if needed.
+     *
+     * @param scope             Construct that scopes the auto-created encryption role
+     * @param routerOutputArn   Optional ARN of the consuming router output — when provided,
+     *                          scopes the auto-created encryption role's trust policy.
+     *
+     * @internal
+     */
+    _bind(scope, routerOutputArn) {
+        if (!this._encryption) {
+            return { name: this._protocolName, config: this._config };
+        }
+        const { config: encryptionConfiguration, grant } = (0, shared_1.resolveRouterSrtEncryption)(scope, 'EncryptionRole', this._encryption, routerOutputArn);
+        if (this._config.srtListener) {
+            return {
+                name: this._protocolName,
+                config: { srtListener: { ...this._config.srtListener, encryptionConfiguration } },
+                grant,
+            };
+        }
+        if (this._config.srtCaller) {
+            return {
+                name: this._protocolName,
+                config: { srtCaller: { ...this._config.srtCaller, encryptionConfiguration } },
+                grant,
+            };
+        }
+        return { name: this._protocolName, config: this._config };
+    }
+}
+exports.RouterOutputProtocol = RouterOutputProtocol;
+/**
+ * Factory class for creating Router Output configurations
+ */
+class RouterOutputConfiguration {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.RouterOutputConfiguration", version: "2.263.0-alpha.0" };
+    /**
+     * Create a standard Router Output configuration with a single protocol
+     *
+     * @example
+     *
+     *    declare const networkInterface: RouterNetworkInterface;
+     *
+     *    RouterOutputConfiguration.standard({
+     *      networkInterface,
+     *      protocol: RouterOutputProtocol.rtp({
+     *        destinationAddress: '10.0.0.1',
+     *        port: 5000,
+     *      }),
+     *    });
+     *
+     * @param props Standard configuration properties
+     * @returns RouterOutputConfiguration instance for standard setup
+     */
+    static standard(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_StandardOutputConfigurationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.standard);
+            }
+            throw error;
+        }
+        return new StandardRouterOutputConfig(props);
+    }
+    /**
+     * Create a MediaLive Router Output configuration with a specific input connection.
+     *
+     * Use this when the MediaLive input already exists and you want to connect immediately.
+     *
+     * @example
+     *
+     *    RouterOutputConfiguration.mediaLiveInput({
+     *      mediaLiveInputArn: 'arn:aws:medialive:us-east-1:123456789012:input:1234567',
+     *      mediaLivePipelineId: MediaLivePipeline.PIPELINE_0,
+     *    });
+     *
+     * @param props MediaLive input connection properties
+     * @returns RouterOutputConfiguration instance for MediaLive setup with input connection
+     */
+    static mediaLiveInput(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MediaLiveInputConnectionProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.mediaLiveInput);
+            }
+            throw error;
+        }
+        return new MediaLiveInputRouterOutputConfig({
+            mediaLiveInputArn: props.mediaLiveInputArn,
+            mediaLivePipelineId: props.mediaLivePipelineId,
+            destinationTransitEncryption: props.destinationTransitEncryption,
+        });
+    }
+    /**
+     * Create a MediaLive Router Output configuration without a specific input connection.
+     *
+     * Use this when you want to set up the router output before the MediaLive input exists.
+     *
+     * @example
+     *
+     *    RouterOutputConfiguration.mediaLiveInputWithoutConnection({
+     *      availabilityZone: 'us-east-1a',
+     *    });
+     *
+     * @param props MediaLive no input connection properties
+     * @returns RouterOutputConfiguration instance for MediaLive setup without input connection
+     */
+    static mediaLiveInputWithoutConnection(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MediaLiveNoInputConnectionProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.mediaLiveInputWithoutConnection);
+            }
+            throw error;
+        }
+        return new MediaLiveInputRouterOutputConfig({ destinationTransitEncryption: props.destinationTransitEncryption }, props.availabilityZone);
+    }
+    /**
+     * Create a MediaConnect Flow Router Output configuration with a specific flow connection.
+     *
+     * Use this when the target flow already exists and you want to connect immediately.
+     *
+     * @example
+     *
+     *    declare const flow: Flow;
+     *
+     *    RouterOutputConfiguration.mediaConnectFlow({
+     *      flow,
+     *    });
+     *
+     * @param props MediaConnect Flow connection properties
+     * @returns RouterOutputConfiguration instance for MediaConnect Flow setup with flow connection
+     */
+    static mediaConnectFlow(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MediaConnectFlowConnectionProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.mediaConnectFlow);
+            }
+            throw error;
+        }
+        return new MediaConnectFlowRouterOutputConfig({
+            flow: props.flow,
+            destinationTransitEncryption: props.destinationTransitEncryption,
+        });
+    }
+    /**
+     * Create a MediaConnect Flow Router Output configuration without a specific flow connection.
+     *
+     * Use this when you want to set up the router output before the target flow exists.
+     *
+     * @example
+     *
+     *    RouterOutputConfiguration.mediaConnectFlowWithoutConnection({
+     *      availabilityZone: 'us-east-1a',
+     *    });
+     *
+     * @param props MediaConnect Flow no connection properties
+     * @returns RouterOutputConfiguration instance for MediaConnect Flow setup without flow connection
+     */
+    static mediaConnectFlowWithoutConnection(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MediaConnectFlowNoConnectionProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.mediaConnectFlowWithoutConnection);
+            }
+            throw error;
+        }
+        return new MediaConnectFlowRouterOutputConfig({ destinationTransitEncryption: props.destinationTransitEncryption }, props.availabilityZone);
+    }
+}
+exports.RouterOutputConfiguration = RouterOutputConfiguration;
+/**
+ * Concrete variant: standard (single-protocol) router output configuration.
+ * @internal
+ */
+class StandardRouterOutputConfig extends RouterOutputConfiguration {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    _bind(scope, routerOutputArn) {
+        const protocol = this.props.protocol._bind(scope, routerOutputArn);
+        return {
+            config: {
+                standard: {
+                    networkInterfaceArn: this.props.networkInterface.routerNetworkInterfaceArn,
+                    protocol: protocol.name.value,
+                    protocolConfiguration: protocol.config,
+                },
+            },
+            grant: protocol.grant,
+        };
+    }
+}
+/**
+ * Concrete variant: MediaLive Input router output configuration (with or without connection).
+ * @internal
+ */
+class MediaLiveInputRouterOutputConfig extends RouterOutputConfiguration {
+    options;
+    availabilityZone;
+    constructor(options, availabilityZone) {
+        super();
+        this.options = options;
+        this.availabilityZone = availabilityZone;
+    }
+    _bind(scope, routerOutputArn) {
+        const transit = (0, shared_1.resolveTransitEncryption)(scope, 'DestinationTransitEncryptionRole', this.options.destinationTransitEncryption, routerOutputArn);
+        return {
+            config: {
+                mediaLiveInput: {
+                    mediaLiveInputArn: this.options.mediaLiveInputArn,
+                    mediaLivePipelineId: this.options.mediaLivePipelineId,
+                    destinationTransitEncryption: transit.config,
+                },
+            },
+            availabilityZone: this.availabilityZone,
+            grant: transit.grant,
+        };
+    }
+}
+/**
+ * Concrete variant: MediaConnect Flow router output configuration (with or without connection).
+ * @internal
+ */
+class MediaConnectFlowRouterOutputConfig extends RouterOutputConfiguration {
+    options;
+    availabilityZone;
+    constructor(options, availabilityZone) {
+        super();
+        this.options = options;
+        this.availabilityZone = availabilityZone;
+    }
+    _bind(scope, routerOutputArn) {
+        const transit = (0, shared_1.resolveTransitEncryption)(scope, 'DestinationTransitEncryptionRole', this.options.destinationTransitEncryption, routerOutputArn);
+        return {
+            config: {
+                mediaConnectFlow: {
+                    flowArn: this.options.flow?.flowArn,
+                    flowSourceArn: this.options.flow?.sourceArn,
+                    destinationTransitEncryption: transit.config,
+                },
+            },
+            availabilityZone: this.availabilityZone,
+            grant: transit.grant,
+        };
+    }
+}
+/**
+ * A MediaConnect Router Output that sends media streams to destinations.
+ *
+ * Router Outputs support multiple configuration types:
+ * - Standard: Single protocol output
+ * - MediaLive Input: Output to AWS Elemental MediaLive
+ * - MediaConnect Flow: Output to another MediaConnect Flow
+ */
+class RouterOutputBase extends aws_cdk_lib_1.Resource {
+    /**
+     * A reference to this Router Output resource.
+     * Required by the auto-generated IRouterOutputRef interface.
+     */
+    get routerOutputRef() {
+        return { routerOutputArn: this.routerOutputArn };
+    }
+    /**
+     * Create a CloudWatch metric for this router output.
+     */
+    metric(metricName, props) {
+        return new aws_cloudwatch_1.Metric({
+            metricName,
+            namespace: 'AWS/MediaConnect',
+            ...props,
+            dimensionsMap: {
+                RouterOutputARN: this.routerOutputArn,
+                ...props?.dimensionsMap,
+            },
+        }).attachTo(this);
+    }
+    /**
+     * Metric for the bitrate of the router output's payload.
+     */
+    metricBitrate(props) {
+        return this.metric('RouterOutputBitRate', {
+            statistic: 'avg',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.BITS_PER_SECOND,
+            ...props,
+        });
+    }
+    /**
+     * Metric for the total number of packets sent by the router output.
+     */
+    metricTotalPackets(props) {
+        return this.metric('RouterOutputTotalPackets', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            ...props,
+        });
+    }
+    /**
+     * Metric for the router output connection state (1 connected, 0 disconnected). Applies to SRT outputs only.
+     */
+    metricConnected(props) {
+        return this.metric('RouterOutputConnected', {
+            statistic: 'min',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.NONE,
+            ...props,
+        });
+    }
+    /**
+     * Metric for the number of retransmitted packets requested through ARQ. Applies to RIST and SRT outputs.
+     */
+    metricArqRequests(props) {
+        return this.metric('RouterOutputARQRequests', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            ...props,
+        });
+    }
+}
+/**
+ * Defines an AWS Elemental MediaConnect Router Output.
+ */
+let RouterOutput = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = RouterOutputBase;
+    var RouterOutput = 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);
+            RouterOutput = _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.RouterOutput", version: "2.263.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-mediaconnect-alpha.RouterOutput';
+        /**
+         * Import an existing Router Output from its ARN.
+         *
+         * The ARN only contains the service-generated ID (not the router output name). Accessing
+         * `routerOutputName` on an ARN import throws — use `fromRouterOutputAttributes()` to provide
+         * the name explicitly.
+         *
+         * @param scope The parent construct
+         * @param id The construct id
+         * @param routerOutputArn The ARN of the Router Output
+         * @returns A Router Output construct
+         */
+        static fromRouterOutputArn(scope, id, routerOutputArn) {
+            return RouterOutput.fromRouterOutputAttributes(scope, id, { routerOutputArn });
+        }
+        /**
+         * Import an existing Router Output from attributes.
+         *
+         * Use this when you need to reference a router output by name.
+         *
+         * @param scope The parent construct
+         * @param id The construct id
+         * @param attrs The Router Output attributes
+         * @returns A Router Output construct
+         */
+        static fromRouterOutputAttributes(scope, id, attrs) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_RouterOutputAttributes(attrs);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.fromRouterOutputAttributes);
+                }
+                throw error;
+            }
+            // Derive the ID from the ARN using CFN intrinsics so this works with token ARNs too.
+            // The ARN format is arn:aws:mediaconnect:<region>:<account>:routerOutput:<id>, so the
+            // resource name is the ID.
+            const routerOutputId = attrs.routerOutputId ?? extractRouterOutputId(attrs.routerOutputArn);
+            class Import extends RouterOutputBase {
+                routerOutputArn = attrs.routerOutputArn;
+                routerOutputId = routerOutputId;
+                createdAt = undefined;
+                updatedAt = undefined;
+                get routerOutputName() {
+                    if (attrs.routerOutputName)
+                        return attrs.routerOutputName;
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterOutputNameNotProvided`, `'routerOutputName' was not provided when importing RouterOutput ${this.node.path}; provide it in fromRouterOutputAttributes()`, this);
+                }
+                get ipAddress() {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterOutputIpAddressNotProvided`, `'ipAddress' is not available on imported RouterOutput ${this.node.path}`, 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 === RouterOutputTier.OUTPUT_20.value)
+                return 20;
+            if (tier.value === RouterOutputTier.OUTPUT_50.value)
+                return 50;
+            if (tier.value === RouterOutputTier.OUTPUT_100.value)
+                return 100;
+            return undefined;
+        }
+        routerOutputArn;
+        routerOutputName;
+        routerOutputId;
+        ipAddress;
+        createdAt;
+        updatedAt;
+        constructor(scope, id, props) {
+            super(scope, id, {
+                physicalName: props.routerOutputName ?? aws_cdk_lib_1.Lazy.string({ produce: () => aws_cdk_lib_1.Names.uniqueResourceName(this, { maxLength: 128 }) }),
+            });
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_RouterOutputProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, RouterOutput);
+                }
+                throw error;
+            }
+            // Validate router output name if provided
+            if (props.routerOutputName != null && props.routerOutputName !== '' && !aws_cdk_lib_1.Token.isUnresolved(props.routerOutputName)) {
+                if (props.routerOutputName.length > 128) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterOutputNameLength`, `Router output name must be between 1 and 128 characters, got ${props.routerOutputName.length}`, this);
+                }
+                if (!/^[a-zA-Z0-9-]+$/.test(props.routerOutputName)) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterOutputNameFormat`, `Router output name must contain only alphanumeric characters and hyphens, got '${props.routerOutputName}'`, this);
+                }
+            }
+            // Validate maximum bitrate
+            if (!props.maximumBitrate.isUnresolved() && props.maximumBitrate.toBps() < 1000000) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterOutputMinBitrate`, `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 ?? RouterOutputTier.OUTPUT_20;
+            const tierMbps = RouterOutput.tierLimitMbps(resolvedTier);
+            if ((0, shared_1.exceedsRouterTierBitrate)(tierMbps, props.maximumBitrate)) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterOutputBitrateExceedsTier`, `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-output → role cycle.
+            const routerOutputArn = stack.formatArn({
+                service: 'mediaconnect',
+                region: targetRegion,
+                resource: 'routerOutput',
+                resourceName: '*',
+                arnFormat: aws_cdk_lib_1.ArnFormat.COLON_RESOURCE_NAME,
+            });
+            const configBind = props.configuration._bind(this, routerOutputArn);
+            // Check to see if region specified is also compatible with AZ configured for some of the Router Outputs configurations
+            if (configBind.availabilityZone && !configBind.availabilityZone.startsWith(targetRegion)) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `RouterOutputAzRegionMismatch`, `Availability zone '${configBind.availabilityZone}' must be within region '${targetRegion}'`, this);
+            }
+            const routerOutput = new aws_mediaconnect_1.CfnRouterOutput(this, 'Resource', {
+                name: this.physicalName,
+                maximumBitrate: props.maximumBitrate.toBps(),
+                routingScope: props.routingScope.value,
+                tier: (props.tier ?? RouterOutputTier.OUTPUT_20).value,
+                availabilityZone: configBind.availabilityZone, // Only specified for MediaConnect Flow and MediaLive inputs (with no connection).
+                maintenanceConfiguration: props.maintenanceConfiguration ? {
+                    preferredDayTime: props.maintenanceConfiguration,
+                } : {
+                    default: {},
+                },
+                configuration: configBind.config,
+                regionName: targetRegion,
+                tags: props.tags ? (0, shared_1.renderTags)(props.tags) : undefined,
+            });
+            this.routerOutputArn = routerOutput.attrArn;
+            this.routerOutputName = this.physicalName;
+            this.routerOutputId = routerOutput.attrId;
+            this.ipAddress = routerOutput.attrIpAddress;
+            this.createdAt = routerOutput.attrCreatedAt;
+            this.updatedAt = routerOutput.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.
+            configBind.grant?.applyBefore(routerOutput);
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return RouterOutput = _classThis;
+})();
+exports.RouterOutput = RouterOutput;
+function extractRouterOutputId(routerOutputArn) {
+    const parsed = aws_cdk_lib_1.Arn.split(routerOutputArn, aws_cdk_lib_1.ArnFormat.COLON_RESOURCE_NAME).resourceName;
+    if (parsed === undefined) {
+        throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `InvalidRouterOutputArn`, `Could not parse Router Output ARN: ${routerOutputArn}. Expected format: arn:<partition>:mediaconnect:<region>:<account>:routerOutput:<id>`);
+    }
+    return parsed;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"router-output.js","sourceRoot":"","sources":["router-output.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Bitrate, IResource } from 'aws-cdk-lib';\nimport { Arn, ArnFormat, Duration, 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 type { Grant } from 'aws-cdk-lib/aws-iam';\nimport { CfnRouterOutput } from 'aws-cdk-lib/aws-mediaconnect';\nimport type { IRouterOutputRef, RouterOutputReference } from 'aws-cdk-lib/aws-mediaconnect';\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 { MaintenanceConfiguration, ForwardErrorCorrection, RoutingScope } from './router-input';\nimport type { IRouterNetworkInterface } from './router-network-interface';\nimport type { MediaLivePipeline, RouterSrtEncryption, TransitEncryption } from './shared';\nimport { renderTags, exceedsRouterTierBitrate, resolveRouterSrtEncryption, resolveTransitEncryption, validateMaintenanceTime } from './shared';\n\n/**\n * Protocol options available for Router Output configurations\n */\nexport class RouterOutputProtocolOptions {\n  /** Real-time Transport Protocol */\n  public static readonly RTP = new RouterOutputProtocolOptions('RTP');\n  /** Reliable Internet Stream Transport */\n  public static readonly RIST = new RouterOutputProtocolOptions('RIST');\n  /** Secure Reliable Transport - Caller mode */\n  public static readonly SRT_CALLER = new RouterOutputProtocolOptions('SRT_CALLER');\n  /** Secure Reliable Transport - Listener mode */\n  public static readonly SRT_LISTENER = new RouterOutputProtocolOptions('SRT_LISTENER');\n\n  /**\n   * Use a custom protocol value\n   * @param value The protocol string value\n   */\n  public static of(value: string): RouterOutputProtocolOptions {\n    return new RouterOutputProtocolOptions(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 * Routing tier that determines the maximum bitrate (in Mbps) for a Router Output.\n */\nexport class RouterOutputTier {\n  /** Up to 100 Mbps */\n  public static readonly OUTPUT_100 = new RouterOutputTier('OUTPUT_100');\n  /** Up to 50 Mbps */\n  public static readonly OUTPUT_50 = new RouterOutputTier('OUTPUT_50');\n  /** Up to 20 Mbps */\n  public static readonly OUTPUT_20 = new RouterOutputTier('OUTPUT_20');\n\n  /**\n   * Use a custom tier value\n   * @param value The tier string value\n   */\n  public static of(value: string): RouterOutputTier {\n    return new RouterOutputTier(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 * Interface for Router Output\n */\nexport interface IRouterOutput extends IResource, IRouterOutputRef {\n  /**\n   * The name of the router output.\n   *\n   * @attribute\n   */\n  readonly routerOutputName: string;\n\n  /**\n   * The Amazon Resource Name (ARN) of the router output.\n   *\n   * @attribute\n   */\n  readonly routerOutputArn: string;\n\n  /**\n   * The unique identifier of the router output.\n   *\n   * @attribute\n   */\n  readonly routerOutputId: string;\n\n  /**\n   * The IP address of the router output.\n   *\n   * @attribute\n   */\n  readonly ipAddress: string;\n\n  /**\n   * The timestamp when the router output was created.\n   *\n   * @attribute\n   */\n  readonly createdAt?: string;\n\n  /**\n   * The timestamp when the router output was last updated.\n   *\n   * @attribute\n   */\n  readonly updatedAt?: string;\n\n  /**\n   * Create a CloudWatch metric for this router output.\n   *\n   * Router output metrics are dimensioned by `RouterOutputARN`. See the MediaConnect\n   * documentation for available metric names (e.g. `RouterOutputBitRate`,\n   * `RouterOutputTotalPackets`).\n   */\n  metric(metricName: string, props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the bitrate of the router output's payload.\n   * @default - average over 60 seconds\n   */\n  metricBitrate(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the total number of packets sent by the router output.\n   * @default - sum over 60 seconds\n   */\n  metricTotalPackets(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the router output connection state (1 connected, 0 disconnected). Applies to SRT outputs only.\n   * @default - minimum over 60 seconds\n   */\n  metricConnected(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the number of retransmitted packets requested through automatic repeat request (ARQ).\n   * Applies to RIST and SRT outputs only.\n   *\n   * @default - sum over 60 seconds\n   */\n  metricArqRequests(props?: MetricOptions): Metric;\n}\n\n/**\n * Properties for creating a Router Output\n */\nexport interface RouterOutputProps {\n  /**\n   * Name of the Router Output\n   * @default - Generated automatically\n   */\n  readonly routerOutputName?: string;\n  /** Maximum bitrate in bits per second that the Router Output can handle */\n  readonly maximumBitrate: Bitrate;\n  /** Routing scope for the Router Output */\n  readonly routingScope: RoutingScope;\n  /**\n   * Routing tier that determines the maximum number of outputs.\n   *\n   * @default RouterOutputTier.OUTPUT_20\n   */\n  readonly tier?: RouterOutputTier;\n  /** Configuration for the Router Output (standard, MediaConnect Flow, or MediaLive) */\n  readonly configuration: RouterOutputConfiguration;\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 Output will be created\n   * @default - Defaults to the same region as stack\n   */\n  readonly regionName?: string;\n  /**\n   * Tags to add to the Router Output\n   * @default - No tagging\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * Attributes for importing an existing Router Output.\n */\nexport interface RouterOutputAttributes {\n  /**\n   * The ARN of the router output.\n   */\n  readonly routerOutputArn: string;\n\n  /**\n   * The name of the router output.\n   *\n   * The name is not encoded in the ARN (the ARN contains only the service-generated ID),\n   * so provide it here if you need to access `routerOutputName` on the imported construct.\n   *\n   * @default - routerOutputName is not available on the imported construct\n   */\n  readonly routerOutputName?: string;\n\n  /**\n   * The unique identifier of the router output.\n   *\n   * @default - parsed from the ARN when available\n   */\n  readonly routerOutputId?: string;\n}\n\n/**\n * Properties for RTP protocol configuration for outputs\n */\nexport interface RtpOutputProtocolProps {\n  /** Destination IP address for RTP traffic */\n  readonly destinationAddress: string;\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 for outputs\n */\nexport interface RistOutputProtocolProps {\n  /** Destination IP address for RIST traffic */\n  readonly destinationAddress: string;\n  /** Port number for RIST traffic */\n  readonly port: number;\n}\n\n/**\n * Properties for SRT Listener protocol configuration for outputs\n */\nexport interface SrtListenerOutputProtocolProps {\n  /** Port number for SRT listener */\n  readonly port: number;\n  /** Minimum latency for SRT */\n  readonly minimumLatency: Duration;\n  /**\n   * Optional encryption configuration for SRT streams\n   * @default - No encryption\n   */\n  readonly encryptionConfiguration?: RouterSrtEncryption;\n}\n\n/**\n * Properties for SRT Caller protocol configuration for outputs\n */\nexport interface SrtCallerOutputProtocolProps {\n  /** Destination IP address to connect to */\n  readonly destinationAddress: string;\n  /** Destination port to connect to */\n  readonly destinationPort: 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 encryption configuration for SRT streams\n   * @default - No encryption\n   */\n  readonly encryptionConfiguration?: RouterSrtEncryption;\n}\n\n/**\n * Factory class for creating Router Output protocol configurations.\n *\n * Supported protocols: RTP, RIST, SRT (Listener and Caller).\n */\nexport class RouterOutputProtocol {\n  /**\n   * Create an RTP protocol configuration\n   *\n   * @example\n   *\n   *    RouterOutputProtocol.rtp({\n   *      destinationAddress: '10.0.0.1',\n   *      port: 5000,\n   *    });\n   *\n   * @param props RTP protocol properties\n   * @returns RouterOutputProtocol instance configured for RTP\n   */\n  public static rtp(props: RtpOutputProtocolProps): RouterOutputProtocol {\n    RouterOutputProtocol.validatePort(props.port);\n    return new RouterOutputProtocol(RouterOutputProtocolOptions.RTP, {\n      rtp: {\n        destinationAddress: props.destinationAddress,\n        destinationPort: props.port,\n        forwardErrorCorrection: props.forwardErrorCorrection,\n      },\n    });\n  }\n\n  /**\n   * Create a RIST protocol configuration\n   *\n   * @example\n   *\n   *    RouterOutputProtocol.rist({\n   *      destinationAddress: '10.0.0.1',\n   *      port: 5000,\n   *    });\n   *\n   * @param props RIST protocol properties\n   * @returns RouterOutputProtocol instance configured for RIST\n   */\n  public static rist(props: RistOutputProtocolProps): RouterOutputProtocol {\n    RouterOutputProtocol.validatePort(props.port);\n    return new RouterOutputProtocol(RouterOutputProtocolOptions.RIST, {\n      rist: {\n        destinationAddress: props.destinationAddress,\n        destinationPort: props.port,\n      },\n    });\n  }\n\n  /**\n   * Create an SRT Listener protocol configuration\n   *\n   * @example\n   *\n   *    RouterOutputProtocol.srtListener({\n   *      port: 5000,\n   *      minimumLatency: Duration.millis(125),\n   *    });\n   *\n   * @param props SRT Listener protocol properties\n   * @returns RouterOutputProtocol instance configured for SRT Listener\n   */\n  public static srtListener(props: SrtListenerOutputProtocolProps): RouterOutputProtocol {\n    RouterOutputProtocol.validatePort(props.port);\n    return new RouterOutputProtocol(RouterOutputProtocolOptions.SRT_LISTENER, {\n      srtListener: {\n        port: props.port,\n        minimumLatencyMilliseconds: props.minimumLatency.toMilliseconds(),\n      },\n    }, props.encryptionConfiguration);\n  }\n\n  /**\n   * Create an SRT Caller protocol configuration\n   *\n   * @example\n   *\n   *    RouterOutputProtocol.srtCaller({\n   *      destinationAddress: '10.0.0.1',\n   *      destinationPort: 5000,\n   *      minimumLatency: Duration.millis(125),\n   *    });\n   *\n   * @param props SRT Caller protocol properties\n   * @returns RouterOutputProtocol instance configured for SRT Caller\n   */\n  public static srtCaller(props: SrtCallerOutputProtocolProps): RouterOutputProtocol {\n    RouterOutputProtocol.validateSrtCallerPort(props.destinationPort);\n    return new RouterOutputProtocol(RouterOutputProtocolOptions.SRT_CALLER, {\n      srtCaller: {\n        destinationAddress: props.destinationAddress,\n        destinationPort: props.destinationPort,\n        minimumLatencyMilliseconds: props.minimumLatency.toMilliseconds(),\n        streamId: props.streamId,\n      },\n    }, props.encryptionConfiguration);\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`RouterOutputPortRange`, `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: RouterOutputProtocolOptions;\n  private readonly _config: CfnRouterOutput.RouterOutputProtocolConfigurationProperty;\n  private readonly _encryption?: RouterSrtEncryption;\n\n  private constructor(\n    protocolName: RouterOutputProtocolOptions,\n    config: CfnRouterOutput.RouterOutputProtocolConfigurationProperty,\n    encryption?: RouterSrtEncryption,\n  ) {\n    this._protocolName = protocolName;\n    this._config = config;\n    this._encryption = encryption;\n  }\n\n  /**\n   * Resolve this protocol to its CFN-ready form. Returns the protocol identifier\n   * and the CFN configuration shape with SRT encryption auto-role materialized if needed.\n   *\n   * @param scope             Construct that scopes the auto-created encryption role\n   * @param routerOutputArn   Optional ARN of the consuming router output — when provided,\n   *                          scopes the auto-created encryption role's trust policy.\n   *\n   * @internal\n   */\n  public _bind(scope: Construct, routerOutputArn?: string): {\n    name: RouterOutputProtocolOptions;\n    config: CfnRouterOutput.RouterOutputProtocolConfigurationProperty;\n    grant?: Grant;\n  } {\n    if (!this._encryption) {\n      return { name: this._protocolName, config: this._config };\n    }\n\n    const { config: encryptionConfiguration, grant } = resolveRouterSrtEncryption(scope, 'EncryptionRole', this._encryption, routerOutputArn);\n\n    if (this._config.srtListener) {\n      return {\n        name: this._protocolName,\n        config: { srtListener: { ...this._config.srtListener, encryptionConfiguration } },\n        grant,\n      };\n    }\n    if (this._config.srtCaller) {\n      return {\n        name: this._protocolName,\n        config: { srtCaller: { ...this._config.srtCaller, encryptionConfiguration } },\n        grant,\n      };\n    }\n    return { name: this._protocolName, config: this._config };\n  }\n}\n\n/**\n * Properties for standard Router Output configuration\n */\nexport interface StandardOutputConfigurationProps {\n  /** Network interface for the Router Output */\n  readonly networkInterface: IRouterNetworkInterface;\n  /** Protocol configuration for the output */\n  readonly protocol: RouterOutputProtocol;\n}\n\n/**\n * Properties for MediaLive Router Output configuration with specific input connection\n */\nexport interface MediaLiveInputConnectionProps {\n  /**\n   * ARN of the MediaLive input to send output to.\n   *\n   * Note: This will change to accept an IInputRef (typed MediaLive Input reference)\n   * when the @aws-cdk/aws-medialive-alpha L2 construct is released.\n   */\n  readonly mediaLiveInputArn: string;\n  /** Pipeline ID for MediaLive input */\n  readonly mediaLivePipelineId: MediaLivePipeline;\n  /**\n   * Optional transit encryption configuration\n   * @default - Automatic encryption will be used\n   */\n  readonly destinationTransitEncryption?: TransitEncryption;\n}\n\n/**\n * Properties for MediaLive Router Output configuration without specific input connection\n */\nexport interface MediaLiveNoInputConnectionProps {\n  /** Availability zone for the router output when not connecting to a specific input */\n  readonly availabilityZone: string;\n  /**\n   * Optional transit encryption configuration\n   * @default - Automatic encryption will be used\n   */\n  readonly destinationTransitEncryption?: TransitEncryption;\n}\n\n/**\n * Properties for MediaConnect Flow Router Output configuration with specific flow connection\n */\nexport interface MediaConnectFlowConnectionProps {\n  /** MediaConnect Flow to send output to */\n  readonly flow: IFlow;\n  /**\n   * Optional transit encryption configuration\n   * @default - Automatic encryption will be used\n   */\n  readonly destinationTransitEncryption?: TransitEncryption;\n}\n\n/**\n * Properties for MediaConnect Flow Router Output configuration without specific flow connection\n */\nexport interface MediaConnectFlowNoConnectionProps {\n  /** Availability zone for the router output when not connecting to a specific flow */\n  readonly availabilityZone: string;\n  /**\n   * Optional transit encryption configuration\n   * @default - Automatic encryption will be used\n   */\n  readonly destinationTransitEncryption?: TransitEncryption;\n}\n\n/**\n * Factory class for creating Router Output configurations\n */\nexport abstract class RouterOutputConfiguration {\n  /**\n   * Create a standard Router Output configuration with a single protocol\n   *\n   * @example\n   *\n   *    declare const networkInterface: RouterNetworkInterface;\n   *\n   *    RouterOutputConfiguration.standard({\n   *      networkInterface,\n   *      protocol: RouterOutputProtocol.rtp({\n   *        destinationAddress: '10.0.0.1',\n   *        port: 5000,\n   *      }),\n   *    });\n   *\n   * @param props Standard configuration properties\n   * @returns RouterOutputConfiguration instance for standard setup\n   */\n  public static standard(props: StandardOutputConfigurationProps): RouterOutputConfiguration {\n    return new StandardRouterOutputConfig(props);\n  }\n\n  /**\n   * Create a MediaLive Router Output configuration with a specific input connection.\n   *\n   * Use this when the MediaLive input already exists and you want to connect immediately.\n   *\n   * @example\n   *\n   *    RouterOutputConfiguration.mediaLiveInput({\n   *      mediaLiveInputArn: 'arn:aws:medialive:us-east-1:123456789012:input:1234567',\n   *      mediaLivePipelineId: MediaLivePipeline.PIPELINE_0,\n   *    });\n   *\n   * @param props MediaLive input connection properties\n   * @returns RouterOutputConfiguration instance for MediaLive setup with input connection\n   */\n  public static mediaLiveInput(props: MediaLiveInputConnectionProps): RouterOutputConfiguration {\n    return new MediaLiveInputRouterOutputConfig({\n      mediaLiveInputArn: props.mediaLiveInputArn,\n      mediaLivePipelineId: props.mediaLivePipelineId,\n      destinationTransitEncryption: props.destinationTransitEncryption,\n    });\n  }\n\n  /**\n   * Create a MediaLive Router Output configuration without a specific input connection.\n   *\n   * Use this when you want to set up the router output before the MediaLive input exists.\n   *\n   * @example\n   *\n   *    RouterOutputConfiguration.mediaLiveInputWithoutConnection({\n   *      availabilityZone: 'us-east-1a',\n   *    });\n   *\n   * @param props MediaLive no input connection properties\n   * @returns RouterOutputConfiguration instance for MediaLive setup without input connection\n   */\n  public static mediaLiveInputWithoutConnection(props: MediaLiveNoInputConnectionProps): RouterOutputConfiguration {\n    return new MediaLiveInputRouterOutputConfig(\n      { destinationTransitEncryption: props.destinationTransitEncryption },\n      props.availabilityZone,\n    );\n  }\n\n  /**\n   * Create a MediaConnect Flow Router Output configuration with a specific flow connection.\n   *\n   * Use this when the target flow already exists and you want to connect immediately.\n   *\n   * @example\n   *\n   *    declare const flow: Flow;\n   *\n   *    RouterOutputConfiguration.mediaConnectFlow({\n   *      flow,\n   *    });\n   *\n   * @param props MediaConnect Flow connection properties\n   * @returns RouterOutputConfiguration instance for MediaConnect Flow setup with flow connection\n   */\n  public static mediaConnectFlow(props: MediaConnectFlowConnectionProps): RouterOutputConfiguration {\n    return new MediaConnectFlowRouterOutputConfig({\n      flow: props.flow,\n      destinationTransitEncryption: props.destinationTransitEncryption,\n    });\n  }\n\n  /**\n   * Create a MediaConnect Flow Router Output configuration without a specific flow connection.\n   *\n   * Use this when you want to set up the router output before the target flow exists.\n   *\n   * @example\n   *\n   *    RouterOutputConfiguration.mediaConnectFlowWithoutConnection({\n   *      availabilityZone: 'us-east-1a',\n   *    });\n   *\n   * @param props MediaConnect Flow no connection properties\n   * @returns RouterOutputConfiguration instance for MediaConnect Flow setup without flow connection\n   */\n  public static mediaConnectFlowWithoutConnection(props: MediaConnectFlowNoConnectionProps): RouterOutputConfiguration {\n    return new MediaConnectFlowRouterOutputConfig(\n      { destinationTransitEncryption: props.destinationTransitEncryption },\n      props.availabilityZone,\n    );\n  }\n\n  /**\n   * Resolve this configuration to its CloudFormation shape. Called by the RouterOutput\n   * constructor — each concrete subclass supplies its own variant-specific rendering.\n   * @internal\n   */\n  public abstract _bind(scope: Construct, routerOutputArn?: string): {\n    config: CfnRouterOutput.RouterOutputConfigurationProperty; availabilityZone?: string; grant?: Grant;\n  };\n}\n\n/**\n * Concrete variant: standard (single-protocol) router output configuration.\n * @internal\n */\nclass StandardRouterOutputConfig extends RouterOutputConfiguration {\n  constructor(private readonly props: StandardOutputConfigurationProps) { super(); }\n\n  public _bind(scope: Construct, routerOutputArn?: string) {\n    const protocol = this.props.protocol._bind(scope, routerOutputArn);\n    return {\n      config: {\n        standard: {\n          networkInterfaceArn: this.props.networkInterface.routerNetworkInterfaceArn,\n          protocol: protocol.name.value,\n          protocolConfiguration: protocol.config,\n        },\n      },\n      grant: protocol.grant,\n    };\n  }\n}\n\n/**\n * Concrete variant: MediaLive Input router output configuration (with or without connection).\n * @internal\n */\nclass MediaLiveInputRouterOutputConfig extends RouterOutputConfiguration {\n  constructor(\n    private readonly options: MediaLiveInputRouterOutputOptions,\n    private readonly availabilityZone?: string,\n  ) { super(); }\n\n  public _bind(scope: Construct, routerOutputArn?: string) {\n    const transit = resolveTransitEncryption(scope, 'DestinationTransitEncryptionRole', this.options.destinationTransitEncryption, routerOutputArn);\n    return {\n      config: {\n        mediaLiveInput: {\n          mediaLiveInputArn: this.options.mediaLiveInputArn,\n          mediaLivePipelineId: this.options.mediaLivePipelineId,\n          destinationTransitEncryption: transit.config,\n        },\n      },\n      availabilityZone: this.availabilityZone,\n      grant: transit.grant,\n    };\n  }\n}\n\n/**\n * Internal options for {@link MediaLiveInputRouterOutputConfig}. Not exported; jsii never sees this.\n */\ninterface MediaLiveInputRouterOutputOptions {\n  readonly mediaLiveInputArn?: string;\n  readonly mediaLivePipelineId?: MediaLivePipeline;\n  readonly destinationTransitEncryption?: TransitEncryption;\n}\n\n/**\n * Concrete variant: MediaConnect Flow router output configuration (with or without connection).\n * @internal\n */\nclass MediaConnectFlowRouterOutputConfig extends RouterOutputConfiguration {\n  constructor(\n    private readonly options: MediaConnectFlowRouterOutputOptions,\n    private readonly availabilityZone?: string,\n  ) { super(); }\n\n  public _bind(scope: Construct, routerOutputArn?: string) {\n    const transit = resolveTransitEncryption(scope, 'DestinationTransitEncryptionRole', this.options.destinationTransitEncryption, routerOutputArn);\n    return {\n      config: {\n        mediaConnectFlow: {\n          flowArn: this.options.flow?.flowArn,\n          flowSourceArn: this.options.flow?.sourceArn,\n          destinationTransitEncryption: transit.config,\n        },\n      },\n      availabilityZone: this.availabilityZone,\n      grant: transit.grant,\n    };\n  }\n}\n\n/**\n * Internal options for {@link MediaConnectFlowRouterOutputConfig}. Not exported; jsii never sees this.\n */\ninterface MediaConnectFlowRouterOutputOptions {\n  readonly flow?: IFlow;\n  readonly destinationTransitEncryption?: TransitEncryption;\n}\n\n/**\n * A MediaConnect Router Output that sends media streams to destinations.\n *\n * Router Outputs support multiple configuration types:\n * - Standard: Single protocol output\n * - MediaLive Input: Output to AWS Elemental MediaLive\n * - MediaConnect Flow: Output to another MediaConnect Flow\n */\nabstract class RouterOutputBase extends Resource implements IRouterOutput {\n  public abstract readonly routerOutputArn: string;\n  public abstract readonly routerOutputName: string;\n  public abstract readonly routerOutputId: string;\n  public abstract readonly ipAddress: string;\n  public abstract readonly createdAt?: string;\n  public abstract readonly updatedAt?: string;\n\n  /**\n   * A reference to this Router Output resource.\n   * Required by the auto-generated IRouterOutputRef interface.\n   */\n  public get routerOutputRef(): RouterOutputReference {\n    return { routerOutputArn: this.routerOutputArn };\n  }\n\n  /**\n   * Create a CloudWatch metric for this router output.\n   */\n  public metric(metricName: string, props?: MetricOptions): Metric {\n    return new Metric({\n      metricName,\n      namespace: 'AWS/MediaConnect',\n      ...props,\n      dimensionsMap: {\n        RouterOutputARN: this.routerOutputArn,\n        ...props?.dimensionsMap,\n      },\n    }).attachTo(this);\n  }\n\n  /**\n   * Metric for the bitrate of the router output's payload.\n   */\n  public metricBitrate(props?: MetricOptions): Metric {\n    return this.metric('RouterOutputBitRate', {\n      statistic: 'avg',\n      period: Duration.seconds(60),\n      unit: Unit.BITS_PER_SECOND,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the total number of packets sent by the router output.\n   */\n  public metricTotalPackets(props?: MetricOptions): Metric {\n    return this.metric('RouterOutputTotalPackets', {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.COUNT,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the router output connection state (1 connected, 0 disconnected). Applies to SRT outputs only.\n   */\n  public metricConnected(props?: MetricOptions): Metric {\n    return this.metric('RouterOutputConnected', {\n      statistic: 'min',\n      period: Duration.seconds(60),\n      unit: Unit.NONE,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the number of retransmitted packets requested through ARQ. Applies to RIST and SRT outputs.\n   */\n  public metricArqRequests(props?: MetricOptions): Metric {\n    return this.metric('RouterOutputARQRequests', {\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 Output.\n */\n@propertyInjectable\nexport class RouterOutput extends RouterOutputBase implements IRouterOutput {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-mediaconnect-alpha.RouterOutput';\n\n  /**\n   * Import an existing Router Output from its ARN.\n   *\n   * The ARN only contains the service-generated ID (not the router output name). Accessing\n   * `routerOutputName` on an ARN import throws — use `fromRouterOutputAttributes()` to provide\n   * the name explicitly.\n   *\n   * @param scope The parent construct\n   * @param id The construct id\n   * @param routerOutputArn The ARN of the Router Output\n   * @returns A Router Output construct\n   */\n  public static fromRouterOutputArn(scope: Construct, id: string, routerOutputArn: string): IRouterOutput {\n    return RouterOutput.fromRouterOutputAttributes(scope, id, { routerOutputArn });\n  }\n\n  /**\n   * Import an existing Router Output from attributes.\n   *\n   * Use this when you need to reference a router output by name.\n   *\n   * @param scope The parent construct\n   * @param id The construct id\n   * @param attrs The Router Output attributes\n   * @returns A Router Output construct\n   */\n  public static fromRouterOutputAttributes(scope: Construct, id: string, attrs: RouterOutputAttributes): IRouterOutput {\n    // Derive the ID from the ARN using CFN intrinsics so this works with token ARNs too.\n    // The ARN format is arn:aws:mediaconnect:<region>:<account>:routerOutput:<id>, so the\n    // resource name is the ID.\n    const routerOutputId = attrs.routerOutputId ?? extractRouterOutputId(attrs.routerOutputArn);\n\n    class Import extends RouterOutputBase implements IRouterOutput {\n      public readonly routerOutputArn = attrs.routerOutputArn;\n      public readonly routerOutputId = routerOutputId;\n      public readonly createdAt = undefined;\n      public readonly updatedAt = undefined;\n\n      public get routerOutputName(): string {\n        if (attrs.routerOutputName) return attrs.routerOutputName;\n        throw new ValidationError(\n          lit`RouterOutputNameNotProvided`,\n          `'routerOutputName' was not provided when importing RouterOutput ${this.node.path}; provide it in fromRouterOutputAttributes()`,\n          this,\n        );\n      }\n\n      public get ipAddress(): string {\n        throw new ValidationError(\n          lit`RouterOutputIpAddressNotProvided`,\n          `'ipAddress' is not available on imported RouterOutput ${this.node.path}`,\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: RouterOutputTier): number | undefined {\n    if (tier.value === RouterOutputTier.OUTPUT_20.value) return 20;\n    if (tier.value === RouterOutputTier.OUTPUT_50.value) return 50;\n    if (tier.value === RouterOutputTier.OUTPUT_100.value) return 100;\n    return undefined;\n  }\n\n  public readonly routerOutputArn: string;\n  public readonly routerOutputName: string;\n  public readonly routerOutputId: string;\n  public readonly ipAddress: string;\n  public readonly createdAt?: string;\n  public readonly updatedAt?: string;\n\n  constructor(scope: Construct, id: string, props: RouterOutputProps) {\n    super(scope, id, {\n      physicalName: props.routerOutputName ?? Lazy.string({ produce: () => Names.uniqueResourceName(this, { maxLength: 128 }) }),\n    });\n\n    // Validate router output name if provided\n    if (props.routerOutputName != null && props.routerOutputName !== '' && !Token.isUnresolved(props.routerOutputName)) {\n      if (props.routerOutputName.length > 128) {\n        throw new ValidationError(lit`RouterOutputNameLength`, `Router output name must be between 1 and 128 characters, got ${props.routerOutputName.length}`, this);\n      }\n      if (!/^[a-zA-Z0-9-]+$/.test(props.routerOutputName)) {\n        throw new ValidationError(lit`RouterOutputNameFormat`, `Router output name must contain only alphanumeric characters and hyphens, got '${props.routerOutputName}'`, this);\n      }\n    }\n\n    // Validate maximum bitrate\n    if (!props.maximumBitrate.isUnresolved() && props.maximumBitrate.toBps() < 1000000) {\n      throw new ValidationError(lit`RouterOutputMinBitrate`, `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 ?? RouterOutputTier.OUTPUT_20;\n    const tierMbps = RouterOutput.tierLimitMbps(resolvedTier);\n    if (exceedsRouterTierBitrate(tierMbps, props.maximumBitrate)) {\n      throw new ValidationError(lit`RouterOutputBitrateExceedsTier`, `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-output → role cycle.\n    const routerOutputArn = stack.formatArn({\n      service: 'mediaconnect',\n      region: targetRegion,\n      resource: 'routerOutput',\n      resourceName: '*',\n      arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n    });\n\n    const configBind = props.configuration._bind(this, routerOutputArn);\n\n    // Check to see if region specified is also compatible with AZ configured for some of the Router Outputs configurations\n    if (configBind.availabilityZone && !configBind.availabilityZone.startsWith(targetRegion)) {\n      throw new ValidationError(lit`RouterOutputAzRegionMismatch`, `Availability zone '${configBind.availabilityZone}' must be within region '${targetRegion}'`, this);\n    }\n\n    const routerOutput = new CfnRouterOutput(this, 'Resource', {\n      name: this.physicalName,\n      maximumBitrate: props.maximumBitrate.toBps(),\n      routingScope: props.routingScope.value,\n      tier: (props.tier ?? RouterOutputTier.OUTPUT_20).value,\n      availabilityZone: configBind.availabilityZone, // Only specified for MediaConnect Flow and MediaLive inputs (with no connection).\n      maintenanceConfiguration: props.maintenanceConfiguration ? {\n        preferredDayTime: props.maintenanceConfiguration,\n      } : {\n        default: {},\n      },\n      configuration: configBind.config,\n      regionName: targetRegion,\n      tags: props.tags ? renderTags(props.tags) : undefined,\n    });\n\n    this.routerOutputArn = routerOutput.attrArn;\n    this.routerOutputName = this.physicalName;\n    this.routerOutputId = routerOutput.attrId;\n    this.ipAddress = routerOutput.attrIpAddress;\n    this.createdAt = routerOutput.attrCreatedAt;\n    this.updatedAt = routerOutput.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    configBind.grant?.applyBefore(routerOutput);\n  }\n}\n\nfunction extractRouterOutputId(routerOutputArn: string): string {\n  const parsed = Arn.split(routerOutputArn, ArnFormat.COLON_RESOURCE_NAME).resourceName;\n  if (parsed === undefined) {\n    throw new UnscopedValidationError(\n      lit`InvalidRouterOutputArn`,\n      `Could not parse Router Output ARN: ${routerOutputArn}. Expected format: arn:<partition>:mediaconnect:<region>:<account>:routerOutput:<id>`,\n    );\n  }\n  return parsed;\n}\n"]}