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

package/lib/flow.js

@@ -0,0 +1,1065 @@
+"use strict";
+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;
+};
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flow = exports.MediaStream = exports.MediaVideoFormat = exports.AudioStreamOrderOptions = exports.Tcs = exports.ScanMode = exports.VideoRange = exports.Colorimetry = exports.EncodingProfile = exports.FailoverConfig = exports.FlowSize = 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 flow_output_1 = require("./flow-output");
+const flow_source_configuration_1 = require("./flow-source-configuration");
+const mediaconnect_grants_generated_1 = require("./mediaconnect-grants.generated");
+const shared_1 = require("./shared");
+/**
+ * Options for Flow Size
+ */
+class FlowSize {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.FlowSize", version: "2.263.0-alpha.0" };
+    /**
+     * Medium flow size. The default — standard transport stream distribution; does not
+     * support NDI, CDI, or JPEG XS.
+     *
+     * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/flow-sizes-capabilities.html
+     */
+    static MEDIUM = new FlowSize('MEDIUM');
+    /**
+     * Large flow size. Required when the flow uses NDI sources or outputs. Supports
+     * transport stream distribution plus NDI; does not support CDI or JPEG XS.
+     *
+     * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/flow-sizes-capabilities.html
+     */
+    static LARGE = new FlowSize('LARGE');
+    /**
+     * Option for large 4x flow size. Required for JPEG XS and CDI protocols. Does not support transport streams or NDI.
+     */
+    static LARGE_4X = new FlowSize('LARGE_4X');
+    /**
+     * Use a custom flow size value
+     * @param value The flow size string value
+     */
+    static of(value) {
+        return new FlowSize(value);
+    }
+    /** @param value The flow size string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.FlowSize = FlowSize;
+/**
+ * Source failover configuration for a flow.
+ *
+ * MediaConnect supports two failover modes:
+ * - {@link FailoverConfig.merge} combines two binary-identical sources into a single
+ *   stream, recovering lost packets from the other source (SMPTE 2022-7).
+ * - {@link FailoverConfig.failover} switches between a primary and backup source when
+ *   the active source stops receiving data.
+ */
+class FailoverConfig {
+    _failoverMode;
+    _state;
+    _recoveryWindow;
+    _primarySource;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.FailoverConfig", version: "2.263.0-alpha.0" };
+    /**
+     * Configure merge-mode failover. Requires two binary-identical sources.
+     */
+    static merge(options = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MergeFailoverOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.merge);
+            }
+            throw error;
+        }
+        if (options.recoveryWindow) {
+            const ms = options.recoveryWindow.toMilliseconds();
+            if (ms < 100 || ms > 15000) {
+                throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `RecoveryWindowRange`, `Recovery window must be between 100 and 15000 ms, got ${ms}`);
+            }
+        }
+        return new FailoverConfig(shared_1.FailoverMode.MERGE, options.state ?? shared_1.State.ENABLED, options.recoveryWindow, undefined);
+    }
+    /**
+     * Configure switchover-mode failover. The flow swaps to the backup source when the
+     * primary source stops receiving data.
+     */
+    static failover(options = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_FailoverFailoverOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.failover);
+            }
+            throw error;
+        }
+        return new FailoverConfig(shared_1.FailoverMode.FAILOVER, options.state ?? shared_1.State.ENABLED, undefined, options.primarySource);
+    }
+    constructor(_failoverMode, _state, _recoveryWindow, _primarySource) {
+        this._failoverMode = _failoverMode;
+        this._state = _state;
+        this._recoveryWindow = _recoveryWindow;
+        this._primarySource = _primarySource;
+    }
+    /**
+     * Whether this configuration has failover enabled.
+     * @internal
+     */
+    get _isEnabled() {
+        return this._state === shared_1.State.ENABLED;
+    }
+    /**
+     * Called when the configuration is bound to a Flow.
+     * @internal
+     */
+    _bind() {
+        return {
+            failoverMode: this._failoverMode.value,
+            recoveryWindow: this._recoveryWindow?.toMilliseconds(),
+            sourcePriority: this._primarySource ? { primarySource: this._primarySource } : undefined,
+            state: this._state,
+        };
+    }
+}
+exports.FailoverConfig = FailoverConfig;
+/**
+ * Encoding profiles supported when transcoding an NDI source to a transport stream.
+ */
+var EncodingProfile;
+(function (EncodingProfile) {
+    /**
+     * H.264 profile tuned for contribution workflows — higher quality, higher bitrate.
+     */
+    EncodingProfile["CONTRIBUTION_H264_DEFAULT"] = "CONTRIBUTION_H264_DEFAULT";
+    /**
+     * H.264 profile tuned for distribution workflows — lower bitrate, wider compatibility.
+     */
+    EncodingProfile["DISTRIBUTION_H264_DEFAULT"] = "DISTRIBUTION_H264_DEFAULT";
+})(EncodingProfile || (exports.EncodingProfile = EncodingProfile = {}));
+/**
+ * Option for Colorimetry
+ */
+class Colorimetry {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.Colorimetry", version: "2.263.0-alpha.0" };
+    /** Option for BT601 */
+    static BT601 = new Colorimetry('BT601');
+    /** Option for BT709 */
+    static BT709 = new Colorimetry('BT709');
+    /** Option for BT2020 */
+    static BT2020 = new Colorimetry('BT2020');
+    /** Option for BT2100 */
+    static BT2100 = new Colorimetry('BT2100');
+    /** Option for ST2065-1 */
+    static ST2065_1 = new Colorimetry('ST2065-1');
+    /** Option for ST2065-3 */
+    static ST2065_3 = new Colorimetry('ST2065-3');
+    /** Option for XYZ */
+    static XYZ = new Colorimetry('XYZ');
+    /** Use a custom colorimetry value */
+    static of(value) { return new Colorimetry(value); }
+    /** @param value The colorimetry string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() { return this.value; }
+}
+exports.Colorimetry = Colorimetry;
+/**
+ * Options for Video Range
+ */
+class VideoRange {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.VideoRange", version: "2.263.0-alpha.0" };
+    /** Option for Narrow */
+    static NARROW = new VideoRange('NARROW');
+    /** Option for Full */
+    static FULL = new VideoRange('FULL');
+    /** Option for Full Protect */
+    static FULLPROTECT = new VideoRange('FULLPROTECT');
+    /** Use a custom video range value */
+    static of(value) { return new VideoRange(value); }
+    /** @param value The video range string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() { return this.value; }
+}
+exports.VideoRange = VideoRange;
+/**
+ * Options for Scan Mode
+ */
+class ScanMode {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.ScanMode", version: "2.263.0-alpha.0" };
+    /** Option for Progressive */
+    static PROGRESSIVE = new ScanMode('progressive');
+    /** Option for Interlace */
+    static INTERLACE = new ScanMode('interlace');
+    /** Option for Progressive Segmented Frame */
+    static PROGRESSIVE_SEGMENTED_FRAME = new ScanMode('progressive-segmented-frame');
+    /** Use a custom scan mode value */
+    static of(value) { return new ScanMode(value); }
+    /** @param value The scan mode string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() { return this.value; }
+}
+exports.ScanMode = ScanMode;
+/**
+ * Options for Tcs
+ */
+class Tcs {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.Tcs", version: "2.263.0-alpha.0" };
+    /** Option for SDR */
+    static SDR = new Tcs('SDR');
+    /** Option for PQ */
+    static PQ = new Tcs('PQ');
+    /** Option for HLG */
+    static HLG = new Tcs('HLG');
+    /** Option for Linear */
+    static LINEAR = new Tcs('LINEAR');
+    /** Option for BT2100LINPQ */
+    static BT2100LINPQ = new Tcs('BT2100LINPQ');
+    /** Option for BT2100LINHLG */
+    static BT2100LINHLG = new Tcs('BT2100LINHLG');
+    /** Option for ST2065-1 */
+    static ST2065_1 = new Tcs('ST2065-1');
+    /** Option for ST428-1 */
+    static ST428_1 = new Tcs('ST428-1');
+    /** Option for Density */
+    static DENSITY = new Tcs('DENSITY');
+    /** Use a custom TCS value */
+    static of(value) { return new Tcs(value); }
+    /** @param value The TCS string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() { return this.value; }
+}
+exports.Tcs = Tcs;
+/**
+ * Audio Stream Order Options
+ */
+class AudioStreamOrderOptions {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.AudioStreamOrderOptions", version: "2.263.0-alpha.0" };
+    /** Mono */
+    static MONO = new AudioStreamOrderOptions('SMPTE2110.(M)');
+    /** Dual Mono */
+    static DUAL_MONO = new AudioStreamOrderOptions('SMPTE2110.(DM)');
+    /** Standard Stereo */
+    static STANDARD_STEREO = new AudioStreamOrderOptions('SMPTE2110.(ST)');
+    /** Left Right Matrix Stereo */
+    static LTRT_MATRIX_STEREO = new AudioStreamOrderOptions('SMPTE2110.(LtRt)');
+    /** 5.1 Surround */
+    static SURROUND_5_1 = new AudioStreamOrderOptions('SMPTE2110.(51)');
+    /** 7.1 Surround */
+    static SURROUND_7_1 = new AudioStreamOrderOptions('SMPTE2110.(71)');
+    /** 22.2 Surround */
+    static SURROUND_22_2 = new AudioStreamOrderOptions('SMPTE2110.(222)');
+    /** One SDI Audio Group */
+    static ONE_SDI_AUDIO_GROUP = new AudioStreamOrderOptions('SMPTE2110.(SGRP)');
+    /** Use a custom audio stream order value */
+    static of(value) { return new AudioStreamOrderOptions(value); }
+    /** @param value The audio stream order string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() { return this.value; }
+}
+exports.AudioStreamOrderOptions = AudioStreamOrderOptions;
+/**
+ * Options for Media Stream Type
+ *
+ * @internal
+ */
+var MediaStreamType;
+(function (MediaStreamType) {
+    /**
+     * Option for Video
+     */
+    MediaStreamType["VIDEO"] = "video";
+    /**
+     * Option for Audio
+     */
+    MediaStreamType["AUDIO"] = "audio";
+    /**
+     * Option for ancillary data
+     */
+    MediaStreamType["ANCILLARY_DATA"] = "ancillary-data";
+})(MediaStreamType || (MediaStreamType = {}));
+/**
+ * Options for Media Video format
+ */
+class MediaVideoFormat {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.MediaVideoFormat", version: "2.263.0-alpha.0" };
+    /** Option for 2160p */
+    static UHD_2160P = new MediaVideoFormat('2160p');
+    /** Option for 1080p */
+    static HD_1080P = new MediaVideoFormat('1080p');
+    /** Option for 1080i */
+    static HD_1080I = new MediaVideoFormat('1080i');
+    /** Option for 720p */
+    static HD_720P = new MediaVideoFormat('720p');
+    /** Option for 480p */
+    static SD_480P = new MediaVideoFormat('480p');
+    /** Use a custom video format value */
+    static of(value) { return new MediaVideoFormat(value); }
+    /** @param value The video format string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() { return this.value; }
+}
+exports.MediaVideoFormat = MediaVideoFormat;
+/**
+ * Simplified configuration for Media Streams
+ */
+class MediaStream {
+    _config;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.MediaStream", version: "2.263.0-alpha.0" };
+    /**
+     * Configuration for MediaStream Video
+     */
+    static video(config) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MediaStreamVideo(config);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.video);
+            }
+            throw error;
+        }
+        return new MediaStream({
+            mediaStreamId: config.mediaStreamId,
+            mediaStreamName: config.mediaStreamName,
+            videoFormat: config.videoFormat.value,
+            clockRate: config.clockRate,
+            fmt: config.fmt,
+            description: config.description,
+            attributes: {
+                fmtp: {
+                    exactFramerate: config.fmtp.exactFramerate?.toString(),
+                    par: config.fmtp.par?.toString(),
+                    colorimetry: config.fmtp.colorimetry?.value,
+                    range: config.fmtp.videoRange?.value,
+                    scanMode: config.fmtp.scanMode?.value,
+                    tcs: config.fmtp.tcs?.value,
+                },
+            },
+            mediaStreamType: MediaStreamType.VIDEO,
+        });
+    }
+    /**
+     * Configuration for MediaStream audio
+     */
+    static audio(config) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MediaStreamAudio(config);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.audio);
+            }
+            throw error;
+        }
+        return new MediaStream({
+            mediaStreamId: config.mediaStreamId,
+            mediaStreamName: config.mediaStreamName,
+            clockRate: config.clockRate,
+            fmt: config.fmt,
+            description: config.description,
+            attributes: {
+                fmtp: {
+                    channelOrder: config.channelOrder?.value,
+                },
+                lang: config.lang,
+            },
+            mediaStreamType: MediaStreamType.AUDIO,
+        });
+    }
+    /**
+     * Configuration for MediaStream ancillary data
+     */
+    static ancillaryData(config) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_MediaStreamAncillaryData(config);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.ancillaryData);
+            }
+            throw error;
+        }
+        return new MediaStream({
+            mediaStreamId: config.mediaStreamId,
+            mediaStreamName: config.mediaStreamName,
+            description: config.description,
+            mediaStreamType: MediaStreamType.ANCILLARY_DATA,
+        });
+    }
+    constructor(_config) {
+        this._config = _config;
+    }
+    /**
+     * @internal
+     */
+    _bind() {
+        return this._config;
+    }
+}
+exports.MediaStream = MediaStream;
+class FlowBase extends aws_cdk_lib_1.Resource {
+    /**
+     * Creates a Flow construct that represents an external (imported) Flow.
+     */
+    static fromFlowAttributes(scope, id, attrs) {
+        class Import extends FlowBase {
+            flowArn = attrs.flowArn;
+            flowAvailabilityZone = attrs.flowAvailabilityZone;
+            // Imported flows default to `false`. Pass `isFailoverEnabled: true` in the
+            // attributes when the real service-side flow has failover enabled and you
+            // need to add a FlowSource.
+            isFailoverEnabled = attrs.isFailoverEnabled ?? false;
+            get sourceArn() {
+                if (attrs.sourceArn)
+                    return attrs.sourceArn;
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `SourceArnNotProvided`, `'sourceArn' was not provided when importing Flow ${this.node.path}; provide 'sourceArn' in fromFlowAttributes()`, this);
+            }
+            get egressIp() {
+                if (attrs.egressIp)
+                    return attrs.egressIp;
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `EgressIpNotProvided`, `'egressIp' was not provided when importing Flow ${this.node.path}; provide it in fromFlowAttributes()`, this);
+            }
+            get sourceIngestIp() {
+                if (attrs.sourceIngestIp)
+                    return attrs.sourceIngestIp;
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `SourceIngestIpNotProvided`, `'sourceIngestIp' was not provided when importing Flow ${this.node.path}; provide it in fromFlowAttributes()`, this);
+            }
+            get sourceIngestPort() {
+                if (attrs.sourceIngestPort)
+                    return attrs.sourceIngestPort;
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `SourceIngestPortNotProvided`, `'sourceIngestPort' was not provided when importing Flow ${this.node.path}; provide it in fromFlowAttributes()`, this);
+            }
+            get sourceIngestUrl() {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `SourceIngestUrlNotAvailableImported`, `'sourceIngestUrl' is not available on imported Flow ${this.node.path}; only Flows constructed in this app for listener-style source protocols (RTP, RTP-FEC, RIST, SRT listener, Zixi push) expose a source ingest URL`, this);
+            }
+        }
+        return new Import(scope, id);
+    }
+    /**
+     * Import an existing Flow from its ARN.
+     *
+     * Use `fromFlowAttributes()` instead if you need access to `sourceArn` or any other
+     * attribute not encoded in the flow ARN.
+     */
+    static fromFlowArn(scope, id, flowArn) {
+        return Flow.fromFlowAttributes(scope, id, { flowArn });
+    }
+    /**
+     * The NDI state for this flow. `undefined` for imported flows (state is unknown).
+     * @internal
+     */
+    _ndiState;
+    /**
+     * The source protocol value for this flow. `undefined` for imported flows.
+     * @internal
+     */
+    _sourceProtocol;
+    /**
+     * Tracks the number of NDI outputs added to this flow. Used to enforce the
+     * documented "max 1 NDI output per flow" limit.
+     * @internal
+     */
+    _ndiOutputCount = 0;
+    /**
+     * Collection of grant methods for this flow.
+     */
+    grants = mediaconnect_grants_generated_1.FlowGrants.fromFlow(this);
+    /**
+     * A reference to this Flow resource.
+     * Required by the auto-generated IFlowRef interface.
+     */
+    get flowRef() {
+        return {
+            flowArn: this.flowArn,
+        };
+    }
+    /**
+     * Add an output to this flow
+     */
+    addOutput(id, outputConfig) {
+        const protocol = outputConfig._bind().protocol;
+        if (protocol === 'ndi-speed-hq') {
+            if (this._ndiState !== undefined && this._ndiState !== shared_1.State.ENABLED) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `NdiOutputRequiresNdiConfig`, 'NDI outputs require ndiConfig with ndiState set to State.ENABLED on the flow', this);
+            }
+            // NDI passthrough is not supported — a flow cannot have both an NDI source
+            // and an NDI output. The service rejects this at deploy; fail fast here.
+            if (this._sourceProtocol === flow_source_configuration_1.SourceProtocol.NDI_SPEED_HQ.value) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `NdiPassthroughNotSupported`, 'NDI passthrough is not supported. A flow cannot have both an NDI source and an NDI output', this);
+            }
+            // A flow supports a maximum of 1 NDI output (Large flow size, transport
+            // stream protocols + 1 NDI output).
+            // @see https://docs.aws.amazon.com/mediaconnect/latest/ug/flow-sizes-capabilities.html
+            if (this._ndiOutputCount >= 1) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `NdiOutputLimit`, 'A flow supports a maximum of 1 NDI output', this);
+            }
+            this._ndiOutputCount++;
+        }
+        return new flow_output_1.FlowOutput(this, id, {
+            flow: this,
+            output: outputConfig,
+        });
+    }
+    /**
+     * Create a CloudWatch metric for this flow.
+     */
+    metric(metricName, props) {
+        return new aws_cloudwatch_1.Metric({
+            metricName,
+            namespace: 'AWS/MediaConnect',
+            dimensionsMap: {
+                FlowARN: this.flowArn,
+            },
+            ...props,
+        }).attachTo(this);
+    }
+    /**
+     * Metric for the bitrate of content ingested into the flow.
+     *
+     * Emits the `SourceBitRate` metric with dimension `FlowARN`, which aggregates across
+     * all sources on the flow. To narrow to a specific source on a multi-source flow, call
+     * {@link metric} with an additional `SourceARN` dimension.
+     *
+     * @default - average over 60 seconds
+     */
+    metricSourceBitrate(props) {
+        return this.metric('SourceBitRate', {
+            statistic: 'avg',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.BITS_PER_SECOND,
+            ...props,
+        });
+    }
+    /**
+     * Metric for packets that were lost in transit and not recovered by error correction.
+     *
+     * Emits the `SourceNotRecoveredPackets` metric with dimension `FlowARN`, which aggregates
+     * across all sources on the flow.
+     *
+     * @default - sum over 60 seconds
+     */
+    metricSourceNotRecoveredPackets(props) {
+        return this.metric('SourceNotRecoveredPackets', {
+            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 flow sources.
+     *
+     * Emits the `SourceTotalPackets` metric with dimension `FlowARN`, which aggregates across
+     * all sources on the flow.
+     *
+     * @default - sum over 60 seconds
+     */
+    metricSourceTotalPackets(props) {
+        return this.metric('SourceTotalPackets', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            ...props,
+        });
+    }
+    /**
+     * Metric indicating which source is selected for ingest when using `Failover` failover mode.
+     * A value of 1 indicates the source is being used as the input; 0 indicates it is standby.
+     *
+     * Emits the `SourceSelected` metric with dimension `FlowARN`. To narrow to a specific source,
+     * call {@link metric} with an additional `SourceARN` dimension.
+     *
+     * @default - maximum over 60 seconds
+     */
+    metricSourceSelected(props) {
+        return this.metric('SourceSelected', {
+            statistic: 'max',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.NONE,
+            ...props,
+        });
+    }
+    /**
+     * Metric indicating the connection state of the source. 1 for connected, 0 for disconnected.
+     * Applies only to Zixi, SRT, and RIST sources.
+     *
+     * Emits the `SourceConnected` metric with dimension `FlowARN`.
+     *
+     * @default - minimum over 60 seconds
+     */
+    metricSourceConnected(props) {
+        return this.metric('SourceConnected', {
+            statistic: 'min',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.NONE,
+            ...props,
+        });
+    }
+    /**
+     * Metric for the number of times the source transitioned from connected to disconnected.
+     *
+     * Emits the `SourceDisconnections` metric with dimension `FlowARN`.
+     *
+     * @default - sum over 60 seconds
+     */
+    metricSourceDisconnections(props) {
+        return this.metric('SourceDisconnections', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            ...props,
+        });
+    }
+    /**
+     * Metric for the number of packets lost during transit, measured before any error
+     * correction takes place.
+     *
+     * Emits the `SourceDroppedPackets` metric with dimension `FlowARN`.
+     *
+     * @default - sum over 60 seconds
+     */
+    metricSourceDroppedPackets(props) {
+        return this.metric('SourceDroppedPackets', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            ...props,
+        });
+    }
+    /**
+     * Metric for the percentage of packets lost during transit, even if they were recovered.
+     *
+     * Emits the `SourcePacketLossPercent` metric with dimension `FlowARN`.
+     *
+     * @default - average over 60 seconds
+     */
+    metricSourcePacketLossPercent(props) {
+        return this.metric('SourcePacketLossPercent', {
+            statistic: 'avg',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.PERCENT,
+            ...props,
+        });
+    }
+    /**
+     * Metric for the round-trip time between the source and MediaConnect. Applies only to
+     * RIST, Zixi, and SRT sources.
+     *
+     * Emits the `SourceRoundTripTime` metric with dimension `FlowARN`.
+     *
+     * @default - average over 60 seconds
+     */
+    metricSourceRoundTripTime(props) {
+        return this.metric('SourceRoundTripTime', {
+            statistic: 'avg',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.MILLISECONDS,
+            ...props,
+        });
+    }
+    /**
+     * Metric for the current network jitter of the source, measured in milliseconds.
+     *
+     * Emits the `SourceJitter` metric with dimension `FlowARN`.
+     *
+     * @default - average over 60 seconds
+     */
+    metricSourceJitter(props) {
+        return this.metric('SourceJitter', {
+            statistic: 'avg',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.MILLISECONDS,
+            ...props,
+        });
+    }
+}
+/**
+ * Defines an AWS Elemental MediaConnect Flow.
+ */
+let Flow = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = FlowBase;
+    let _instanceExtraInitializers = [];
+    let _addVpcInterface_decorators;
+    var Flow = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _addVpcInterface_decorators = [(0, metadata_resource_1.MethodMetadata)()];
+            __esDecorate(this, null, _addVpcInterface_decorators, { kind: "method", name: "addVpcInterface", static: false, private: false, access: { has: obj => "addVpcInterface" in obj, get: obj => obj.addVpcInterface }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Flow = _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.Flow", version: "2.263.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-mediaconnect-alpha.Flow';
+        /**
+         * The set of source protocols where the flow opens an IP:port and listens for
+         * upstream content. Determines availability of `sourceIngestIp`, `sourceIngestPort`,
+         * and `sourceIngestUrl`. Maps each protocol to the URL scheme used to construct
+         * the ingest URL.
+         */
+        static LISTENER_PROTOCOL_SCHEMES = new Map([
+            ['rtp', 'rtp'],
+            ['rtp-fec', 'rtp'],
+            ['rist', 'rist'],
+            ['srt-listener', 'srt'],
+            ['zixi-push', 'zixi'],
+        ]);
+        static isListenerStyleProtocol(protocol) {
+            return protocol !== undefined && Flow.LISTENER_PROTOCOL_SCHEMES.has(protocol);
+        }
+        flowArn = __runInitializers(this, _instanceExtraInitializers);
+        sourceArn;
+        egressIp;
+        _sourceIngestIp;
+        _sourceIngestPort;
+        _hasListenerSource;
+        flowAvailabilityZone;
+        isFailoverEnabled = false;
+        vpcInterfaces = [];
+        get sourceIngestIp() {
+            if (!this._hasListenerSource) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `SourceIngestIpNotAvailableSourceProtocol`, `'sourceIngestIp' is not available on this Flow ${this.node.path}; only listener-style source protocols (RTP, RTP-FEC, RIST, SRT listener, Zixi push) expose a source ingest IP — CDI, JPEG XS, entitlement, gateway bridge, router, and SRT caller sources do not`, this);
+            }
+            return this._sourceIngestIp;
+        }
+        get sourceIngestPort() {
+            if (!this._hasListenerSource) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `SourceIngestPortNotAvailableSourceProtocol`, `'sourceIngestPort' is not available on this Flow ${this.node.path}; only listener-style source protocols (RTP, RTP-FEC, RIST, SRT listener, Zixi push) expose a source ingest port — CDI, JPEG XS, entitlement, gateway bridge, router, and SRT caller sources do not`, this);
+            }
+            return this._sourceIngestPort;
+        }
+        get sourceIngestUrl() {
+            if (!this._hasListenerSource) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `SourceIngestUrlNotAvailableSourceProtocol`, `'sourceIngestUrl' is not available on this Flow ${this.node.path}; only listener-style source protocols (RTP, RTP-FEC, RIST, SRT listener, Zixi push) expose a source ingest URL — CDI, JPEG XS, entitlement, gateway bridge, router, and SRT caller sources do not`, this);
+            }
+            return this.computeIngestUrl(this._sourceProtocol, this._sourceIngestIp, this._sourceIngestPort);
+        }
+        constructor(scope, id, props) {
+            super(scope, id, {
+                physicalName: props?.flowName ?? aws_cdk_lib_1.Lazy.string({ produce: () => aws_cdk_lib_1.Names.uniqueResourceName(this, { maxLength: 64 }) }),
+            });
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_FlowProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, Flow);
+                }
+                throw error;
+            }
+            // Validate flow name if provided
+            this.validateName(props);
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            // Validate maintenance start hour format
+            if (props.maintenance) {
+                (0, shared_1.validateMaintenanceTime)(props.maintenance.maintenanceStartHour);
+            }
+            // Validate source monitoring thresholds and content-quality requirements
+            this.validateMonitoring(props);
+            // Validate encoding config video max bitrate range (10-50 Mbps)
+            this.validateEncoding(props);
+            // Only iterate a known-concrete vpcInterfaces list; skip tokenized lists to avoid
+            // pushing the token marker into our internal collection.
+            if (props.vpcInterfaces !== undefined && !aws_cdk_lib_1.Token.isUnresolved(props.vpcInterfaces)) {
+                props.vpcInterfaces.forEach(vpc => this.addVpcInterface(vpc));
+            }
+            this.isFailoverEnabled = props.sourceFailoverConfig?._isEnabled ?? false;
+            const sourceConfig = props.source._bind(this, aws_cdk_lib_1.Stack.of(this).formatArn({
+                service: 'mediaconnect',
+                resource: 'flow',
+                resourceName: `*:${this.physicalName}`,
+                arnFormat: aws_cdk_lib_1.ArnFormat.COLON_RESOURCE_NAME,
+            }));
+            if ((sourceConfig.protocol === flow_source_configuration_1.SourceProtocol.JPEGXS.value || sourceConfig.protocol === flow_source_configuration_1.SourceProtocol.CDI.value)
+                && props.flowSize?.value !== FlowSize.LARGE_4X.value) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `FlowSizeRequired`, 'Flows using JPEG XS and CDI protocols require LARGE_4X flow size; set flowSize to FlowSize.LARGE_4X', this);
+            }
+            // NDI constraints (discovery server limit, protocol conflicts, flow size, source requirements)
+            this.validateNdi(props, sourceConfig);
+            // LARGE_4X only supports CDI and JPEG XS protocols
+            if (props.flowSize?.value === FlowSize.LARGE_4X.value
+                && sourceConfig.protocol !== flow_source_configuration_1.SourceProtocol.JPEGXS.value
+                && sourceConfig.protocol !== flow_source_configuration_1.SourceProtocol.CDI.value) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `FlowSizeLarge4xProtocol`, 'LARGE_4X flow size only supports CDI and JPEG XS protocols', this);
+            }
+            // VPC interface EFA-count limit
+            this.validateVpcEfaCount(props);
+            const flow = new aws_mediaconnect_1.CfnFlow(this, 'Resource', {
+                name: this.physicalName,
+                source: sourceConfig,
+                availabilityZone: props?.availabilityZone,
+                flowSize: props?.flowSize?.value,
+                maintenance: props?.maintenance ? {
+                    maintenanceDay: (0, shared_1.toTitleCase)(props.maintenance.maintenanceDay),
+                    maintenanceStartHour: props.maintenance.maintenanceStartHour,
+                } : undefined,
+                mediaStreams: props.mediaStreams ? props.mediaStreams.map(stream => stream._bind()) : undefined,
+                ndiConfig: props.ndiConfig ? {
+                    machineName: props.ndiConfig.machineName,
+                    ndiState: props.ndiConfig.ndiState,
+                    ndiDiscoveryServers: props.ndiConfig.ndiDiscoveryServers?.map(server => ({
+                        discoveryServerAddress: server.discoveryServerAddress,
+                        discoveryServerPort: server.discoveryServerPort,
+                        vpcInterfaceAdapter: server.vpcInterface.name,
+                    })),
+                } : undefined,
+                encodingConfig: props.encodingConfig ? {
+                    encodingProfile: props.encodingConfig.encodingProfile,
+                    videoMaxBitrate: props.encodingConfig.videoMaxBitrate?.toBps(),
+                } : undefined,
+                sourceFailoverConfig: props.sourceFailoverConfig?._bind(),
+                sourceMonitoringConfig: props.sourceMonitoringConfig ? {
+                    contentQualityAnalysisState: props.sourceMonitoringConfig.contentQualityAnalysisState,
+                    thumbnailState: props.sourceMonitoringConfig.thumbnailState,
+                    audioMonitoringSettings: props.sourceMonitoringConfig.silentAudio ? [{
+                            silentAudio: {
+                                state: props.sourceMonitoringConfig.silentAudio.state,
+                                thresholdSeconds: props.sourceMonitoringConfig.silentAudio.threshold.toSeconds(),
+                            },
+                        }] : undefined,
+                    videoMonitoringSettings: props.sourceMonitoringConfig.blackFrames || props.sourceMonitoringConfig.frozenFrames ? [{
+                            blackFrames: props.sourceMonitoringConfig.blackFrames ? {
+                                state: props.sourceMonitoringConfig.blackFrames.state,
+                                thresholdSeconds: props.sourceMonitoringConfig.blackFrames.threshold.toSeconds(),
+                            } : undefined,
+                            frozenFrames: props.sourceMonitoringConfig.frozenFrames ? {
+                                state: props.sourceMonitoringConfig.frozenFrames.state,
+                                thresholdSeconds: props.sourceMonitoringConfig.frozenFrames.threshold.toSeconds(),
+                            } : undefined,
+                        }] : undefined,
+                } : undefined,
+                vpcInterfaces: aws_cdk_lib_1.Lazy.any({ produce: () => this.vpcInterfaces }, { omitEmptyArray: true }),
+            });
+            this.flowArn = flow.attrFlowArn;
+            this.sourceArn = flow.attrSourceSourceArn;
+            this.egressIp = flow.attrEgressIp;
+            this._sourceIngestIp = flow.attrSourceIngestIp;
+            this._sourceIngestPort = flow.attrSourceSourceIngestPort;
+            this.flowAvailabilityZone = flow.attrFlowAvailabilityZone;
+            this._ndiState = props.ndiConfig?.ndiState ?? shared_1.State.DISABLED;
+            this._sourceProtocol = sourceConfig.protocol;
+            this._hasListenerSource = Flow.isListenerStyleProtocol(sourceConfig.protocol);
+            this.node.addValidation({
+                validate: () => {
+                    const names = this.vpcInterfaces.map(v => v.name).filter(n => !aws_cdk_lib_1.Token.isUnresolved(n));
+                    const duplicates = [...new Set(names.filter((n, i) => names.indexOf(n) !== i))];
+                    return duplicates.length > 0
+                        ? [`VPC interface names must be unique within a flow. Duplicate name(s): ${duplicates.join(', ')}`]
+                        : [];
+                },
+            });
+        }
+        /** Validate the flow name length and character set, when a concrete value is provided. */
+        validateName(props) {
+            if (props.flowName != null && props.flowName !== '' && !aws_cdk_lib_1.Token.isUnresolved(props.flowName)) {
+                if (props.flowName.length > 64) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `FlowNameLength`, `Flow name must be between 1 and 64 characters, got ${props.flowName.length}`, this);
+                }
+                if (!/^[a-zA-Z0-9_-]+$/.test(props.flowName)) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `FlowNameFormat`, `Flow name must contain only alphanumeric characters, hyphens, and underscores, got '${props.flowName}'`, this);
+                }
+            }
+        }
+        /**
+         * Validate source-monitoring thresholds (10-60 seconds) and that the per-metric checks are only
+         * used when content-quality analysis is enabled.
+         */
+        validateMonitoring(props) {
+            const monitoring = props.sourceMonitoringConfig;
+            if (monitoring && (monitoring.silentAudio || monitoring.blackFrames || monitoring.frozenFrames)
+                && monitoring.contentQualityAnalysisState !== shared_1.State.ENABLED) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `MonitoringMetricsRequireContentQualityAnalysis`, 'silentAudio, blackFrames, and frozenFrames require contentQualityAnalysisState to be State.ENABLED', this);
+            }
+            if (monitoring?.silentAudio) {
+                const secs = monitoring.silentAudio.threshold.toSeconds();
+                if (secs < 10 || secs > 60) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `SilentAudioThresholdRange`, `Silent audio threshold must be between 10 and 60 seconds, got ${secs}`, this);
+                }
+            }
+            if (monitoring?.blackFrames) {
+                const secs = monitoring.blackFrames.threshold.toSeconds();
+                if (secs < 10 || secs > 60) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `BlackFramesThresholdRange`, `Black frames threshold must be between 10 and 60 seconds, got ${secs}`, this);
+                }
+            }
+            if (monitoring?.frozenFrames) {
+                const secs = monitoring.frozenFrames.threshold.toSeconds();
+                if (secs < 10 || secs > 60) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `FrozenFramesThresholdRange`, `Frozen frames threshold must be between 10 and 60 seconds, got ${secs}`, this);
+                }
+            }
+        }
+        /** Validate the encoding config's video max bitrate range (10-50 Mbps). */
+        validateEncoding(props) {
+            if (props.encodingConfig?.videoMaxBitrate) {
+                const mbps = props.encodingConfig.videoMaxBitrate.toMbps();
+                if (mbps < 10 || mbps > 50) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `EncodingVideoMaxBitrateRange`, `Encoding config videoMaxBitrate must be between 10 and 50 Mbps, got ${mbps}`, this);
+                }
+            }
+        }
+        /**
+         * Validate NDI constraints: discovery-server limit, mutual exclusivity with CDI/JPEG XS, the
+         * required LARGE flow size, and the requirements an NDI source places on the flow.
+         */
+        validateNdi(props, sourceConfig) {
+            // NDI discovery servers limit (service rejects >3 at deploy time)
+            const discoveryServers = props.ndiConfig?.ndiDiscoveryServers;
+            if (discoveryServers !== undefined && !aws_cdk_lib_1.Token.isUnresolved(discoveryServers) && discoveryServers.length > 3) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `NdiMaxDiscoveryServers`, `NDI config supports a maximum of 3 discovery servers, got ${discoveryServers.length}`, this);
+            }
+            // NDI cannot coexist with CDI or JPEG XS — they require different flow sizes
+            if (props.ndiConfig?.ndiState === shared_1.State.ENABLED
+                && (sourceConfig.protocol === flow_source_configuration_1.SourceProtocol.CDI.value || sourceConfig.protocol === flow_source_configuration_1.SourceProtocol.JPEGXS.value)) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `NdiCdiConflict`, 'NDI cannot be used with CDI or JPEG XS protocols; NDI requires LARGE flow size while CDI and JPEG XS require LARGE_4X', this);
+            }
+            // NDI requires LARGE flow size (not MEDIUM, not LARGE_4X)
+            if (props.ndiConfig?.ndiState === shared_1.State.ENABLED
+                && props.flowSize?.value !== FlowSize.LARGE.value) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `NdiFlowSizeRequired`, 'NDI requires LARGE flow size; set flowSize to FlowSize.LARGE', this);
+            }
+            // NDI sources require NDI to be enabled on the flow
+            if (sourceConfig.protocol === flow_source_configuration_1.SourceProtocol.NDI_SPEED_HQ.value
+                && props.ndiConfig?.ndiState !== shared_1.State.ENABLED) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `NdiSourceRequiresNdiConfig`, 'NDI sources require ndiConfig with ndiState set to State.ENABLED', this);
+            }
+            // NDI sources require LARGE flow size
+            if (sourceConfig.protocol === flow_source_configuration_1.SourceProtocol.NDI_SPEED_HQ.value
+                && props.flowSize?.value !== FlowSize.LARGE.value) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `NdiSourceFlowSizeRequired`, 'NDI sources require LARGE flow size; set flowSize to FlowSize.LARGE', this);
+            }
+            // NDI sources require encodingConfig to transcode into a transport stream
+            if (sourceConfig.protocol === flow_source_configuration_1.SourceProtocol.NDI_SPEED_HQ.value
+                && !props.encodingConfig) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `NdiSourceRequiresEncodingConfig`, 'NDI sources require encodingConfig to transcode the NDI source into a transport stream', this);
+            }
+        }
+        /** Validate the EFA VPC-interface count (at most one), when the list is concrete. */
+        validateVpcEfaCount(props) {
+            // Skip EFA-count validation when the user passed a tokenized vpcInterfaces list;
+            // we can't inspect individual entries in that case.
+            const efaCount = props.vpcInterfaces !== undefined && !aws_cdk_lib_1.Token.isUnresolved(props.vpcInterfaces)
+                ? props.vpcInterfaces.filter(vpc => vpc.networkInterfaceType?.value === shared_1.NetworkInterface.EFA.value).length
+                : 0;
+            if (efaCount > 1) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `FlowMaxEfaInterfaces`, `A flow can have a maximum of 1 EFA VPC interface, got ${efaCount}`, this);
+            }
+        }
+        /**
+         * Build the URL for a listener-style source protocol. The caller must have already
+         * checked `_hasListenerSource`; this method assumes the protocol is in
+         * `LISTENER_PROTOCOL_SCHEMES` and throws an unscoped error otherwise.
+         */
+        computeIngestUrl(protocol, ip, port) {
+            const scheme = protocol === undefined ? undefined : Flow.LISTENER_PROTOCOL_SCHEMES.get(protocol);
+            if (scheme === undefined) {
+                throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `SourceIngestUrlComputeNotListener`, `internal: computeIngestUrl called for non-listener protocol '${protocol}'`);
+            }
+            return aws_cdk_lib_1.Fn.join('', [`${scheme}://`, ip, ':', port]);
+        }
+        /**
+         * Add a VPC interface to this flow.
+         */
+        addVpcInterface(vpc) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_VpcInterfaceConfig(vpc);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.addVpcInterface);
+                }
+                throw error;
+            }
+            this.vpcInterfaces.push({
+                name: vpc.name,
+                networkInterfaceIds: vpc.networkInterfaceIds,
+                networkInterfaceType: vpc.networkInterfaceType?.value,
+                securityGroupIds: vpc.securityGroups.map(sg => sg.securityGroupId),
+                subnetId: vpc.subnet.subnetId,
+                roleArn: vpc.role.roleArn,
+            });
+            return vpc;
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return Flow = _classThis;
+})();
+exports.Flow = Flow;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow.js","sourceRoot":"","sources":["flow.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Bitrate, IResource } from 'aws-cdk-lib';\nimport { ArnFormat, Resource, Lazy, Names, Duration, Stack, Token, Fn, 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 { CfnFlow } from 'aws-cdk-lib/aws-mediaconnect';\nimport type { IFlowRef, FlowReference } from 'aws-cdk-lib/aws-mediaconnect';\nimport { lit } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport { addConstructMetadata, MethodMetadata } 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 { IFlowOutput, OutputConfiguration } from './flow-output';\nimport { FlowOutput } from './flow-output';\nimport type { SourceConfiguration } from './flow-source-configuration';\nimport { SourceProtocol } from './flow-source-configuration';\nimport { FlowGrants } from './mediaconnect-grants.generated';\nimport type { VpcInterfaceConfig, MaintenanceDay, Framerate, PixelAspectRatio } from './shared';\nimport { FailoverMode, NetworkInterface, State, toTitleCase, validateMaintenanceTime } from './shared';\n\n/**\n * Interface for Flow\n */\nexport interface IFlow extends IResource, IFlowRef {\n\n  /**\n   * The Amazon Resource Name (ARN) of the flow.\n   *\n   * @attribute\n   */\n  readonly flowArn: string;\n\n  /**\n   * The Amazon Resource Name (ARN) of the source defined on the flow.\n   *\n   * @attribute\n   */\n  readonly sourceArn: string;\n\n  /**\n   * The IP address that the flow uses to send outbound content.\n   *\n   * @attribute\n   */\n  readonly egressIp: string;\n\n  /**\n   * The IP address that the flow listens on for incoming content.\n   *\n   * Available for listener-style source protocols (RTP, RTP-FEC, RIST, SRT listener,\n   * Zixi push). Accessing this on SRT caller, entitlement, gateway bridge, router,\n   * CDI, JPEG XS, or imported flows throws — those sources don't expose a listening\n   * IP address.\n   *\n   * @attribute\n   */\n  readonly sourceIngestIp: string;\n\n  /**\n   * The port that the flow listens on for incoming content.\n   *\n   * Available for the same listener-style source protocols as `sourceIngestIp`.\n   * Accessing this on SRT caller, entitlement, gateway bridge, router, CDI, JPEG XS,\n   * or imported flows throws.\n   *\n   * @attribute\n   */\n  readonly sourceIngestPort: string;\n\n  /**\n   * The full ingest URL for the flow source, combining protocol, IP, and port.\n   * For example: `srt://203.0.113.10:5000`\n   *\n   * Available for listener-style source protocols (RTP, RTP-FEC, RIST, SRT listener,\n   * Zixi push) where the flow listens for an upstream sender. Accessing this on\n   * SRT caller, entitlement, gateway bridge, router, CDI, JPEG XS, or imported\n   * flows throws — those sources don't expose a single host:port ingest URL.\n   */\n  readonly sourceIngestUrl: string;\n\n  /**\n   * The Availability Zone that the flow was created in.\n   *\n   * @attribute\n   */\n  readonly flowAvailabilityZone?: string;\n\n  /**\n   * Failover Configuration for flow\n   */\n  readonly isFailoverEnabled?: boolean;\n\n  /**\n   * Collection of grant methods for this flow.\n   */\n  readonly grants: FlowGrants;\n\n  /**\n   * Create a CloudWatch metric for this flow.\n   */\n  metric(metricName: string, props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the bitrate of content ingested into the flow.\n   * @default - average over 60 seconds\n   */\n  metricSourceBitrate(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for packets that were not recovered by the flow source.\n   * @default - sum over 60 seconds\n   */\n  metricSourceNotRecoveredPackets(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the total number of packets received by the flow source.\n   * @default - sum over 60 seconds\n   */\n  metricSourceTotalPackets(props?: MetricOptions): Metric;\n\n  /**\n   * Metric indicating which source is selected for ingest when using `Failover` failover mode.\n   * @default - maximum over 60 seconds\n   */\n  metricSourceSelected(props?: MetricOptions): Metric;\n\n  /**\n   * Metric indicating the connection state of the source (1 connected, 0 disconnected).\n   * Applies only to Zixi, SRT, and RIST sources.\n   * @default - minimum over 60 seconds\n   */\n  metricSourceConnected(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the number of times the source transitioned from connected to disconnected.\n   * @default - sum over 60 seconds\n   */\n  metricSourceDisconnections(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the number of packets lost during transit, measured before any error correction.\n   * @default - sum over 60 seconds\n   */\n  metricSourceDroppedPackets(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the percentage of packets lost during transit, even if they were recovered.\n   * @default - average over 60 seconds\n   */\n  metricSourcePacketLossPercent(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the round-trip time between the source and MediaConnect.\n   * Applies only to RIST, Zixi, and SRT sources.\n   * @default - average over 60 seconds\n   */\n  metricSourceRoundTripTime(props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the current network jitter of the source, measured in milliseconds.\n   * @default - average over 60 seconds\n   */\n  metricSourceJitter(props?: MetricOptions): Metric;\n\n  /**\n   * Add an output to this flow\n   */\n  addOutput(id: string, outputConfig: OutputConfiguration): IFlowOutput;\n}\n\n/**\n * Options for Flow Size\n */\nexport class FlowSize {\n  /**\n   * Medium flow size. The default — standard transport stream distribution; does not\n   * support NDI, CDI, or JPEG XS.\n   *\n   * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/flow-sizes-capabilities.html\n   */\n  public static readonly MEDIUM = new FlowSize('MEDIUM');\n  /**\n   * Large flow size. Required when the flow uses NDI sources or outputs. Supports\n   * transport stream distribution plus NDI; does not support CDI or JPEG XS.\n   *\n   * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/flow-sizes-capabilities.html\n   */\n  public static readonly LARGE = new FlowSize('LARGE');\n  /**\n   * Option for large 4x flow size. Required for JPEG XS and CDI protocols. Does not support transport streams or NDI.\n   */\n  public static readonly LARGE_4X = new FlowSize('LARGE_4X');\n\n  /**\n   * Use a custom flow size value\n   * @param value The flow size string value\n   */\n  public static of(value: string): FlowSize {\n    return new FlowSize(value);\n  }\n\n  /** @param value The flow size 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 * Maintenance Window configuration for MediaConnect Flow.\n */\nexport interface MaintenanceWindow {\n  /**\n   * A day of a week when the maintenance will happen.\n   */\n  readonly maintenanceDay: MaintenanceDay;\n  /**\n   * UTC time when the maintenance will happen. Use 24-hour HH:MM format. Minutes must be 00. Example: 13:00.\n   */\n  readonly maintenanceStartHour: string;\n}\n\n/**\n * Options for merge-mode source failover.\n */\nexport interface MergeFailoverOptions {\n  /**\n   * Whether failover is enabled. Set to `State.DISABLED` to keep the configuration\n   * on the flow without switching failover on.\n   *\n   * @default State.ENABLED\n   */\n  readonly state?: State;\n  /**\n   * Search window time to look for SMPTE 2022-7 packets. A larger recovery window\n   * means a longer delay in transmitting the stream, but more room for error\n   * correction. A smaller window means a shorter delay but less room for correction.\n   *\n   * Valid range: 100–15000 ms.\n   *\n   * @default - 200 ms\n   */\n  readonly recoveryWindow?: Duration;\n}\n\n/**\n * Options for switchover-mode source failover.\n */\nexport interface FailoverFailoverOptions {\n  /**\n   * Whether failover is enabled. Set to `State.DISABLED` to keep the configuration\n   * on the flow without switching failover on.\n   *\n   * @default State.ENABLED\n   */\n  readonly state?: State;\n  /**\n   * The name of the source you want to treat as primary. If set, MediaConnect always\n   * uses this source when it is available. When unset, both sources are treated with\n   * equal priority.\n   *\n   * @default - both sources are equal priority\n   */\n  readonly primarySource?: string;\n}\n\n/**\n * Source failover configuration for a flow.\n *\n * MediaConnect supports two failover modes:\n * - {@link FailoverConfig.merge} combines two binary-identical sources into a single\n *   stream, recovering lost packets from the other source (SMPTE 2022-7).\n * - {@link FailoverConfig.failover} switches between a primary and backup source when\n *   the active source stops receiving data.\n */\nexport class FailoverConfig {\n  /**\n   * Configure merge-mode failover. Requires two binary-identical sources.\n   */\n  public static merge(options: MergeFailoverOptions = {}): FailoverConfig {\n    if (options.recoveryWindow) {\n      const ms = options.recoveryWindow.toMilliseconds();\n      if (ms < 100 || ms > 15000) {\n        throw new UnscopedValidationError(lit`RecoveryWindowRange`, `Recovery window must be between 100 and 15000 ms, got ${ms}`);\n      }\n    }\n    return new FailoverConfig(FailoverMode.MERGE, options.state ?? State.ENABLED, options.recoveryWindow, undefined);\n  }\n\n  /**\n   * Configure switchover-mode failover. The flow swaps to the backup source when the\n   * primary source stops receiving data.\n   */\n  public static failover(options: FailoverFailoverOptions = {}): FailoverConfig {\n    return new FailoverConfig(FailoverMode.FAILOVER, options.state ?? State.ENABLED, undefined, options.primarySource);\n  }\n\n  private constructor(\n    private readonly _failoverMode: FailoverMode,\n    private readonly _state: State,\n    private readonly _recoveryWindow: Duration | undefined,\n    private readonly _primarySource: string | undefined,\n  ) {}\n\n  /**\n   * Whether this configuration has failover enabled.\n   * @internal\n   */\n  public get _isEnabled(): boolean {\n    return this._state === State.ENABLED;\n  }\n\n  /**\n   * Called when the configuration is bound to a Flow.\n   * @internal\n   */\n  public _bind(): CfnFlow.FailoverConfigProperty {\n    return {\n      failoverMode: this._failoverMode.value,\n      recoveryWindow: this._recoveryWindow?.toMilliseconds(),\n      sourcePriority: this._primarySource ? { primarySource: this._primarySource } : undefined,\n      state: this._state,\n    };\n  }\n}\n\n/**\n * Configures a source monitoring metric.\n */\nexport interface MonitoringMetric {\n  /**\n   * Whether the metric is enabled or disabled. The threshold is persisted by the\n   * service either way, so you can toggle the metric on and off without losing\n   * the threshold value.\n   */\n  readonly state: State;\n  /**\n   * Threshold in seconds that triggers the metric's alert. Valid range: 10–60 seconds.\n   */\n  readonly threshold: Duration;\n}\n\n/**\n * Source monitoring settings.\n */\nexport interface SourceMonitoringConfig {\n  /**\n   * Indicates whether content quality analysis is enabled or disabled.\n   *\n   * @default - content quality analysis is disabled\n   */\n  readonly contentQualityAnalysisState?: State;\n  /**\n   * The current state of the thumbnail monitoring.\n   *\n   * @default - thumbnail monitoring is disabled\n   */\n  readonly thumbnailState?: State;\n  /**\n   * Silent-audio detection on the source.\n   *\n   * @default - silent audio monitoring is not configured\n   */\n  readonly silentAudio?: MonitoringMetric;\n  /**\n   * Black-frames detection on the source.\n   *\n   * @default - black frames monitoring is not configured\n   */\n  readonly blackFrames?: MonitoringMetric;\n  /**\n   * Frozen-frames detection on the source.\n   *\n   * @default - frozen frames monitoring is not configured\n   */\n  readonly frozenFrames?: MonitoringMetric;\n}\n\n/**\n * NDI Configuration\n */\nexport interface NdiDiscoveryServerConfig {\n  /**\n   * The unique network address of the NDI discovery server.\n   */\n  readonly discoveryServerAddress: string;\n  /**\n   * The port for the NDI discovery server. Defaults to 5959 if a custom port isn't specified.\n   *\n   * @default - undefined; when omitted, MediaConnect applies 5959 at deploy time\n   */\n  readonly discoveryServerPort?: number;\n  /**\n   * The VPC interface that the NDI discovery server uses to reach the flow.\n   */\n  readonly vpcInterface: VpcInterfaceConfig;\n}\n\n/**\n * Configuration for NDI Config\n */\nexport interface NdiConfig {\n  /**\n   * A prefix for the names of the NDI sources that the flow creates.\n   * If a custom name isn't specified, MediaConnect generates a unique 12-character ID as the prefix.\n   *\n   * @default - MediaConnect generates a unique 12-character ID\n   */\n  readonly machineName?: string;\n  /**\n   * Specifies the configuration settings for individual NDI discovery servers.\n   * A maximum of 3 servers is allowed.\n   *\n   * @default - no NDI discovery servers\n   */\n  readonly ndiDiscoveryServers?: NdiDiscoveryServerConfig[];\n  /**\n   * A setting that controls whether NDI sources or outputs can be used in the flow.\n   * Must be ENABLED for the flow to support NDI sources or outputs.\n   *\n   * @default State.DISABLED\n   */\n  readonly ndiState?: State;\n}\n\n/**\n * Encoding profiles supported when transcoding an NDI source to a transport stream.\n */\nexport enum EncodingProfile {\n  /**\n   * H.264 profile tuned for contribution workflows — higher quality, higher bitrate.\n   */\n  CONTRIBUTION_H264_DEFAULT = 'CONTRIBUTION_H264_DEFAULT',\n  /**\n   * H.264 profile tuned for distribution workflows — lower bitrate, wider compatibility.\n   */\n  DISTRIBUTION_H264_DEFAULT = 'DISTRIBUTION_H264_DEFAULT',\n}\n\n/**\n * Encoding configuration applied to an NDI source when transcoding it to a transport\n * stream for downstream distribution.\n */\nexport interface EncodingConfig {\n  /**\n   * The encoding profile to use when transcoding the NDI source content to a transport\n   * stream. You can change this value while the flow is running.\n   *\n   * @default - the MediaConnect service default\n   */\n  readonly encodingProfile?: EncodingProfile;\n\n  /**\n   * The maximum video bitrate to use when transcoding the NDI source to a transport stream.\n   *\n   * The supported range is 10 Mbps – 50 Mbps.\n   *\n   * @default - undefined; when omitted, MediaConnect applies 20 Mbps at deploy time\n   */\n  readonly videoMaxBitrate?: Bitrate;\n}\n\n/**\n * Option for Colorimetry\n */\nexport class Colorimetry {\n  /** Option for BT601 */\n  public static readonly BT601 = new Colorimetry('BT601');\n  /** Option for BT709 */\n  public static readonly BT709 = new Colorimetry('BT709');\n  /** Option for BT2020 */\n  public static readonly BT2020 = new Colorimetry('BT2020');\n  /** Option for BT2100 */\n  public static readonly BT2100 = new Colorimetry('BT2100');\n  /** Option for ST2065-1 */\n  public static readonly ST2065_1 = new Colorimetry('ST2065-1');\n  /** Option for ST2065-3 */\n  public static readonly ST2065_3 = new Colorimetry('ST2065-3');\n  /** Option for XYZ */\n  public static readonly XYZ = new Colorimetry('XYZ');\n\n  /** Use a custom colorimetry value */\n  public static of(value: string): Colorimetry { return new Colorimetry(value); }\n  /** @param value The colorimetry string value */\n  private constructor(public readonly value: string) {}\n  /** Returns the string value */\n  public toString(): string { return this.value; }\n}\n\n/**\n * Options for Video Range\n */\nexport class VideoRange {\n  /** Option for Narrow */\n  public static readonly NARROW = new VideoRange('NARROW');\n  /** Option for Full */\n  public static readonly FULL = new VideoRange('FULL');\n  /** Option for Full Protect */\n  public static readonly FULLPROTECT = new VideoRange('FULLPROTECT');\n\n  /** Use a custom video range value */\n  public static of(value: string): VideoRange { return new VideoRange(value); }\n  /** @param value The video range string value */\n  private constructor(public readonly value: string) {}\n  /** Returns the string value */\n  public toString(): string { return this.value; }\n}\n\n/**\n * Options for Scan Mode\n */\nexport class ScanMode {\n  /** Option for Progressive */\n  public static readonly PROGRESSIVE = new ScanMode('progressive');\n  /** Option for Interlace */\n  public static readonly INTERLACE = new ScanMode('interlace');\n  /** Option for Progressive Segmented Frame */\n  public static readonly PROGRESSIVE_SEGMENTED_FRAME = new ScanMode('progressive-segmented-frame');\n\n  /** Use a custom scan mode value */\n  public static of(value: string): ScanMode { return new ScanMode(value); }\n  /** @param value The scan mode string value */\n  private constructor(public readonly value: string) {}\n  /** Returns the string value */\n  public toString(): string { return this.value; }\n}\n\n/**\n * Options for Tcs\n */\nexport class Tcs {\n  /** Option for SDR */\n  public static readonly SDR = new Tcs('SDR');\n  /** Option for PQ */\n  public static readonly PQ = new Tcs('PQ');\n  /** Option for HLG */\n  public static readonly HLG = new Tcs('HLG');\n  /** Option for Linear */\n  public static readonly LINEAR = new Tcs('LINEAR');\n  /** Option for BT2100LINPQ */\n  public static readonly BT2100LINPQ = new Tcs('BT2100LINPQ');\n  /** Option for BT2100LINHLG */\n  public static readonly BT2100LINHLG = new Tcs('BT2100LINHLG');\n  /** Option for ST2065-1 */\n  public static readonly ST2065_1 = new Tcs('ST2065-1');\n  /** Option for ST428-1 */\n  public static readonly ST428_1 = new Tcs('ST428-1');\n  /** Option for Density */\n  public static readonly DENSITY = new Tcs('DENSITY');\n\n  /** Use a custom TCS value */\n  public static of(value: string): Tcs { return new Tcs(value); }\n  /** @param value The TCS string value */\n  private constructor(public readonly value: string) {}\n  /** Returns the string value */\n  public toString(): string { return this.value; }\n}\n\n/**\n * Options for FMTP Video\n */\nexport interface FmtpVideo {\n  /**\n   * The format used for the representation of color.\n   *\n   * @default - no colorimetry specified\n   */\n  readonly colorimetry?: Colorimetry;\n  /**\n   * The frame rate for the video stream.\n   *\n   * @default - no frame rate specified\n   */\n  readonly exactFramerate?: Framerate;\n  /**\n   * The pixel aspect ratio (PAR) of the video — the shape of a single pixel, not the\n   * display aspect ratio. Use `PixelAspectRatio.SQUARE` for most modern content.\n   *\n   * @default - no pixel aspect ratio specified\n   */\n  readonly par?: PixelAspectRatio;\n  /**\n   * The encoding range of the video.\n   *\n   * @default - no video range specified\n   */\n  readonly videoRange?: VideoRange;\n  /**\n   * The type of compression that was used to smooth the video's appearance.\n   *\n   * @default - no scan mode specified\n   */\n  readonly scanMode?: ScanMode;\n  /**\n   * The transfer characteristic system (TCS) that is used in the video.\n   *\n   * @default - no TCS specified\n   */\n  readonly tcs?: Tcs;\n}\n\n/**\n * Audio Stream Order Options\n */\nexport class AudioStreamOrderOptions {\n  /** Mono */\n  public static readonly MONO = new AudioStreamOrderOptions('SMPTE2110.(M)');\n  /** Dual Mono */\n  public static readonly DUAL_MONO = new AudioStreamOrderOptions('SMPTE2110.(DM)');\n  /** Standard Stereo */\n  public static readonly STANDARD_STEREO = new AudioStreamOrderOptions('SMPTE2110.(ST)');\n  /** Left Right Matrix Stereo */\n  public static readonly LTRT_MATRIX_STEREO = new AudioStreamOrderOptions('SMPTE2110.(LtRt)');\n  /** 5.1 Surround */\n  public static readonly SURROUND_5_1 = new AudioStreamOrderOptions('SMPTE2110.(51)');\n  /** 7.1 Surround */\n  public static readonly SURROUND_7_1 = new AudioStreamOrderOptions('SMPTE2110.(71)');\n  /** 22.2 Surround */\n  public static readonly SURROUND_22_2 = new AudioStreamOrderOptions('SMPTE2110.(222)');\n  /** One SDI Audio Group */\n  public static readonly ONE_SDI_AUDIO_GROUP = new AudioStreamOrderOptions('SMPTE2110.(SGRP)');\n\n  /** Use a custom audio stream order value */\n  public static of(value: string): AudioStreamOrderOptions { return new AudioStreamOrderOptions(value); }\n  /** @param value The audio stream order string value */\n  private constructor(public readonly value: string) {}\n  /** Returns the string value */\n  public toString(): string { return this.value; }\n}\n\n/**\n * Options for Media Stream Type\n *\n * @internal\n */\nenum MediaStreamType {\n  /**\n   * Option for Video\n   */\n  VIDEO='video',\n  /**\n   * Option for Audio\n   */\n  AUDIO='audio',\n  /**\n   * Option for ancillary data\n   */\n  ANCILLARY_DATA='ancillary-data',\n}\n\n/**\n * Options for Media Video format\n */\nexport class MediaVideoFormat {\n  /** Option for 2160p */\n  public static readonly UHD_2160P = new MediaVideoFormat('2160p');\n  /** Option for 1080p */\n  public static readonly HD_1080P = new MediaVideoFormat('1080p');\n  /** Option for 1080i */\n  public static readonly HD_1080I = new MediaVideoFormat('1080i');\n  /** Option for 720p */\n  public static readonly HD_720P = new MediaVideoFormat('720p');\n  /** Option for 480p */\n  public static readonly SD_480P = new MediaVideoFormat('480p');\n\n  /** Use a custom video format value */\n  public static of(value: string): MediaVideoFormat { return new MediaVideoFormat(value); }\n  /** @param value The video format string value */\n  private constructor(public readonly value: string) {}\n  /** Returns the string value */\n  public toString(): string { return this.value; }\n}\n\n/**\n * Base configuration for Media Stream.\n */\nexport interface MediaStreamBase {\n  /**\n   * A unique identifier for the media stream.\n   */\n  readonly mediaStreamId: number;\n  /**\n   * A name that helps you distinguish one media stream from another.\n   */\n  readonly mediaStreamName: string;\n  /**\n   * A description that can help you quickly identify what your media stream is used for.\n   *\n   * @default - no description\n   */\n  readonly description?: string;\n}\n\n/**\n * A media stream represents one component of your content, such as video, audio, or ancillary data.\n * After you add a media stream to your flow, you can associate it with sources and outputs that use\n * the ST 2110 JPEG XS or CDI protocol.\n */\nexport interface MediaStreamVideo extends MediaStreamBase {\n  /**\n   * Attributes that are related to the media stream.\n   */\n  readonly fmtp: FmtpVideo;\n  /**\n   * The sample rate for the stream. This value is measured in Hz.\n   *\n   * @default - default clock rate for the media stream type\n   */\n  readonly clockRate?: number;\n  /**\n   * The format type number (sometimes referred to as RTP payload type) of the media stream.\n   * MediaConnect assigns this value to the media stream. For ST 2110 JPEG XS outputs, you need to provide this value to the receiver.\n   *\n   * @default - assigned by MediaConnect\n   */\n  readonly fmt?: number;\n  /**\n   * The resolution of the video.\n   */\n  readonly videoFormat: MediaVideoFormat;\n}\n\n/**\n * A media stream represents one component of your content, such as video, audio, or ancillary data.\n * After you add a media stream to your flow, you can associate it with sources and outputs that use\n * the ST 2110 JPEG XS or CDI protocol.\n */\nexport interface MediaStreamAudio extends MediaStreamBase {\n  /**\n   * The format of the audio channel.\n   *\n   * @default - the MediaConnect service default\n   */\n  readonly channelOrder?: AudioStreamOrderOptions;\n  /**\n   * The sample rate for the stream. This value is measured in Hz.\n   *\n   * @default - default clock rate for the media stream type\n   */\n  readonly clockRate?: number;\n  /**\n   * The format type number (sometimes referred to as RTP payload type) of the media stream.\n   * MediaConnect assigns this value to the media stream. For ST 2110 JPEG XS outputs, you need to provide this value to the receiver.\n   *\n   * @default - assigned by MediaConnect\n   */\n  readonly fmt?: number;\n  /**\n   * The audio language, in a format that is recognized by the receiver.\n   *\n   * @default - no language specified\n   */\n  readonly lang?: string;\n}\n\n/**\n * A media stream represents one component of your content, such as video, audio, or ancillary data.\n * After you add a media stream to your flow, you can associate it with sources and outputs that use\n * the ST 2110 JPEG XS or CDI protocol.\n */\nexport interface MediaStreamAncillaryData extends MediaStreamBase { }\n\n/**\n * Properties for the Flow\n */\nexport interface FlowProps {\n  /**\n   * The name of the flow.\n   *\n   * @default - autogenerated\n   */\n  readonly flowName?: string;\n\n  /**\n   * The Availability Zone that you want to create the flow in. These options are limited to the Availability Zones within the current AWS Region.\n   *\n   * @default - chosen by MediaConnect\n   */\n  readonly availabilityZone?: string;\n\n  /**\n   * Determines the processing capacity and feature set of the flow. Set this optional parameter to LARGE if you want to enable NDI outputs on the flow.\n   *\n   * @default - undefined; when omitted, MediaConnect applies FlowSize.MEDIUM at deploy time\n   */\n  readonly flowSize?: FlowSize;\n\n  /**\n   * The maintenance window for the flow.\n   *\n   * @default - chosen by MediaConnect\n   */\n  readonly maintenance?: MaintenanceWindow;\n\n  /**\n   * The media streams that are associated with the flow. After you associate a media stream with a source, you can also associate it with outputs on the flow.\n   *\n   * @default No Media Streams\n   */\n  readonly mediaStreams?: MediaStream[];\n\n  /**\n   * Specifies the configuration settings for a flow's NDI source or output. Required when the flow includes an NDI source or output.\n   *\n   * @default No NDI Configuration applied\n   */\n  readonly ndiConfig?: NdiConfig;\n\n  /**\n   * Encoding configuration applied to the NDI source when transcoding it to a transport\n   * stream for downstream distribution.\n   *\n   * Required when the flow source uses the NDI SpeedHQ protocol\n   * (see {@link SourceConfiguration.ndi}).\n   *\n   * @default - no encoding config; required for NDI sources\n   */\n  readonly encodingConfig?: EncodingConfig;\n\n  /**\n   * The settings for the source that you want to use for the new flow.\n   */\n  readonly source: SourceConfiguration;\n\n  /**\n   * The settings for source failover.\n   *\n   * @default No source failover configuration applied\n   */\n  readonly sourceFailoverConfig?: FailoverConfig;\n\n  /**\n   * The settings for source monitoring.\n   *\n   * @default No source monitoring configuration applied\n   */\n  readonly sourceMonitoringConfig?: SourceMonitoringConfig;\n\n  /**\n   * The VPC Interfaces for this flow.\n   *\n   * Use this instead of the FlowVpcInterface construct.\n   *\n   * @default No VPC Interface configuration applied\n   */\n  readonly vpcInterfaces?: VpcInterfaceConfig[];\n\n}\n\n/**\n * Simplified configuration for Media Streams\n */\nexport class MediaStream {\n  /**\n   * Configuration for MediaStream Video\n   */\n  public static video(config: MediaStreamVideo): MediaStream {\n    return new MediaStream({\n      mediaStreamId: config.mediaStreamId,\n      mediaStreamName: config.mediaStreamName,\n      videoFormat: config.videoFormat.value,\n      clockRate: config.clockRate,\n      fmt: config.fmt,\n      description: config.description,\n      attributes: {\n        fmtp: {\n          exactFramerate: config.fmtp.exactFramerate?.toString(),\n          par: config.fmtp.par?.toString(),\n          colorimetry: config.fmtp.colorimetry?.value,\n          range: config.fmtp.videoRange?.value,\n          scanMode: config.fmtp.scanMode?.value,\n          tcs: config.fmtp.tcs?.value,\n        },\n      },\n      mediaStreamType: MediaStreamType.VIDEO,\n    });\n  }\n\n  /**\n   * Configuration for MediaStream audio\n   */\n  public static audio(config: MediaStreamAudio): MediaStream {\n    return new MediaStream({\n      mediaStreamId: config.mediaStreamId,\n      mediaStreamName: config.mediaStreamName,\n      clockRate: config.clockRate,\n      fmt: config.fmt,\n      description: config.description,\n      attributes: {\n        fmtp: {\n          channelOrder: config.channelOrder?.value,\n        },\n        lang: config.lang,\n      },\n      mediaStreamType: MediaStreamType.AUDIO,\n    });\n  }\n\n  /**\n   * Configuration for MediaStream ancillary data\n   */\n  public static ancillaryData(config: MediaStreamAncillaryData): MediaStream {\n    return new MediaStream({\n      mediaStreamId: config.mediaStreamId,\n      mediaStreamName: config.mediaStreamName,\n      description: config.description,\n      mediaStreamType: MediaStreamType.ANCILLARY_DATA,\n    });\n  }\n\n  private constructor(private readonly _config: CfnFlow.MediaStreamProperty) {}\n\n  /**\n   * @internal\n   */\n  public _bind(): CfnFlow.MediaStreamProperty {\n    return this._config;\n  }\n}\n\n/**\n * Attributes for importing an existing Flow.\n */\nexport interface FlowAttributes {\n  /**\n   * The ARN of the flow.\n   */\n  readonly flowArn: string;\n\n  /**\n   * Indicates whether failover configured\n   *\n   * @default false\n   */\n  readonly isFailoverEnabled?: boolean;\n\n  /**\n   * ARN of the source defined on the flow.\n   *\n   * Not encoded in the flow ARN, so must be provided explicitly when you need\n   * access to `sourceArn` on the imported construct.\n   *\n   * @default - sourceArn is not available on the imported construct\n   */\n  readonly sourceArn?: string;\n\n  /**\n   * The IP address that the flow uses to send outbound content.\n   *\n   * @default - accessing `egressIp` on the imported flow throws; only provide when available.\n   */\n  readonly egressIp?: string;\n\n  /**\n   * The IP address that the flow listens on for incoming content.\n   *\n   * @default - accessing `sourceIngestIp` on the imported flow throws; only provide when available.\n   */\n  readonly sourceIngestIp?: string;\n\n  /**\n   * The port that the flow listens on for incoming content.\n   *\n   * @default - accessing `sourceIngestPort` on the imported flow throws; only provide when available.\n   */\n  readonly sourceIngestPort?: string;\n\n  /**\n   * The Availability Zone that the flow was created in.\n   *\n   * @default - `flowAvailabilityZone` is undefined on the imported flow.\n   */\n  readonly flowAvailabilityZone?: string;\n}\n\nabstract class FlowBase extends Resource implements IFlow {\n  /**\n   * Creates a Flow construct that represents an external (imported) Flow.\n   */\n  public static fromFlowAttributes(scope: Construct, id: string, attrs: FlowAttributes): IFlow {\n    class Import extends FlowBase implements IFlow {\n      public readonly flowArn = attrs.flowArn;\n      public readonly flowAvailabilityZone = attrs.flowAvailabilityZone;\n\n      // Imported flows default to `false`. Pass `isFailoverEnabled: true` in the\n      // attributes when the real service-side flow has failover enabled and you\n      // need to add a FlowSource.\n      public isFailoverEnabled?: boolean = attrs.isFailoverEnabled ?? false;\n\n      public get sourceArn(): string {\n        if (attrs.sourceArn) return attrs.sourceArn;\n        throw new ValidationError(\n          lit`SourceArnNotProvided`,\n          `'sourceArn' was not provided when importing Flow ${this.node.path}; provide 'sourceArn' in fromFlowAttributes()`,\n          this,\n        );\n      }\n\n      public get egressIp(): string {\n        if (attrs.egressIp) return attrs.egressIp;\n        throw new ValidationError(\n          lit`EgressIpNotProvided`,\n          `'egressIp' was not provided when importing Flow ${this.node.path}; provide it in fromFlowAttributes()`,\n          this,\n        );\n      }\n\n      public get sourceIngestIp(): string {\n        if (attrs.sourceIngestIp) return attrs.sourceIngestIp;\n        throw new ValidationError(\n          lit`SourceIngestIpNotProvided`,\n          `'sourceIngestIp' was not provided when importing Flow ${this.node.path}; provide it in fromFlowAttributes()`,\n          this,\n        );\n      }\n\n      public get sourceIngestPort(): string {\n        if (attrs.sourceIngestPort) return attrs.sourceIngestPort;\n        throw new ValidationError(\n          lit`SourceIngestPortNotProvided`,\n          `'sourceIngestPort' was not provided when importing Flow ${this.node.path}; provide it in fromFlowAttributes()`,\n          this,\n        );\n      }\n\n      public get sourceIngestUrl(): string {\n        throw new ValidationError(\n          lit`SourceIngestUrlNotAvailableImported`,\n          `'sourceIngestUrl' is not available on imported Flow ${this.node.path}; only Flows constructed in this app for listener-style source protocols (RTP, RTP-FEC, RIST, SRT listener, Zixi push) expose a source ingest URL`,\n          this,\n        );\n      }\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Import an existing Flow from its ARN.\n   *\n   * Use `fromFlowAttributes()` instead if you need access to `sourceArn` or any other\n   * attribute not encoded in the flow ARN.\n   */\n  public static fromFlowArn(scope: Construct, id: string, flowArn: string): IFlow {\n    return Flow.fromFlowAttributes(scope, id, { flowArn });\n  }\n\n  public abstract readonly sourceArn: string;\n  public abstract readonly flowArn: string;\n  public abstract readonly egressIp: string;\n  public abstract readonly sourceIngestIp: string;\n  public abstract readonly sourceIngestPort: string;\n  public abstract readonly sourceIngestUrl: string;\n  public abstract readonly flowAvailabilityZone?: string;\n  public abstract readonly isFailoverEnabled?: boolean;\n\n  /**\n   * The NDI state for this flow. `undefined` for imported flows (state is unknown).\n   * @internal\n   */\n  protected _ndiState?: State;\n\n  /**\n   * The source protocol value for this flow. `undefined` for imported flows.\n   * @internal\n   */\n  protected _sourceProtocol?: string;\n\n  /**\n   * Tracks the number of NDI outputs added to this flow. Used to enforce the\n   * documented \"max 1 NDI output per flow\" limit.\n   * @internal\n   */\n  protected _ndiOutputCount = 0;\n\n  /**\n   * Collection of grant methods for this flow.\n   */\n  public readonly grants = FlowGrants.fromFlow(this);\n\n  /**\n   * A reference to this Flow resource.\n   * Required by the auto-generated IFlowRef interface.\n   */\n  public get flowRef(): FlowReference {\n    return {\n      flowArn: this.flowArn,\n    };\n  }\n\n  /**\n   * Add an output to this flow\n   */\n  public addOutput(id: string, outputConfig: OutputConfiguration): IFlowOutput {\n    const protocol = outputConfig._bind().protocol;\n\n    if (protocol === 'ndi-speed-hq') {\n      if (this._ndiState !== undefined && this._ndiState !== State.ENABLED) {\n        throw new ValidationError(\n          lit`NdiOutputRequiresNdiConfig`,\n          'NDI outputs require ndiConfig with ndiState set to State.ENABLED on the flow',\n          this,\n        );\n      }\n\n      // NDI passthrough is not supported — a flow cannot have both an NDI source\n      // and an NDI output. The service rejects this at deploy; fail fast here.\n      if (this._sourceProtocol === SourceProtocol.NDI_SPEED_HQ.value) {\n        throw new ValidationError(\n          lit`NdiPassthroughNotSupported`,\n          'NDI passthrough is not supported. A flow cannot have both an NDI source and an NDI output',\n          this,\n        );\n      }\n\n      // A flow supports a maximum of 1 NDI output (Large flow size, transport\n      // stream protocols + 1 NDI output).\n      // @see https://docs.aws.amazon.com/mediaconnect/latest/ug/flow-sizes-capabilities.html\n      if (this._ndiOutputCount >= 1) {\n        throw new ValidationError(\n          lit`NdiOutputLimit`,\n          'A flow supports a maximum of 1 NDI output',\n          this,\n        );\n      }\n      this._ndiOutputCount++;\n    }\n\n    return new FlowOutput(this, id, {\n      flow: this,\n      output: outputConfig,\n    });\n  }\n\n  /**\n   * Create a CloudWatch metric for this flow.\n   */\n  public metric(metricName: string, props?: MetricOptions): Metric {\n    return new Metric({\n      metricName,\n      namespace: 'AWS/MediaConnect',\n      dimensionsMap: {\n        FlowARN: this.flowArn,\n      },\n      ...props,\n    }).attachTo(this);\n  }\n\n  /**\n   * Metric for the bitrate of content ingested into the flow.\n   *\n   * Emits the `SourceBitRate` metric with dimension `FlowARN`, which aggregates across\n   * all sources on the flow. To narrow to a specific source on a multi-source flow, call\n   * {@link metric} with an additional `SourceARN` dimension.\n   *\n   * @default - average over 60 seconds\n   */\n  public metricSourceBitrate(props?: MetricOptions): Metric {\n    return this.metric('SourceBitRate', {\n      statistic: 'avg',\n      period: Duration.seconds(60),\n      unit: Unit.BITS_PER_SECOND,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for packets that were lost in transit and not recovered by error correction.\n   *\n   * Emits the `SourceNotRecoveredPackets` metric with dimension `FlowARN`, which aggregates\n   * across all sources on the flow.\n   *\n   * @default - sum over 60 seconds\n   */\n  public metricSourceNotRecoveredPackets(props?: MetricOptions): Metric {\n    return this.metric('SourceNotRecoveredPackets', {\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 flow sources.\n   *\n   * Emits the `SourceTotalPackets` metric with dimension `FlowARN`, which aggregates across\n   * all sources on the flow.\n   *\n   * @default - sum over 60 seconds\n   */\n  public metricSourceTotalPackets(props?: MetricOptions): Metric {\n    return this.metric('SourceTotalPackets', {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.COUNT,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric indicating which source is selected for ingest when using `Failover` failover mode.\n   * A value of 1 indicates the source is being used as the input; 0 indicates it is standby.\n   *\n   * Emits the `SourceSelected` metric with dimension `FlowARN`. To narrow to a specific source,\n   * call {@link metric} with an additional `SourceARN` dimension.\n   *\n   * @default - maximum over 60 seconds\n   */\n  public metricSourceSelected(props?: MetricOptions): Metric {\n    return this.metric('SourceSelected', {\n      statistic: 'max',\n      period: Duration.seconds(60),\n      unit: Unit.NONE,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric indicating the connection state of the source. 1 for connected, 0 for disconnected.\n   * Applies only to Zixi, SRT, and RIST sources.\n   *\n   * Emits the `SourceConnected` metric with dimension `FlowARN`.\n   *\n   * @default - minimum over 60 seconds\n   */\n  public metricSourceConnected(props?: MetricOptions): Metric {\n    return this.metric('SourceConnected', {\n      statistic: 'min',\n      period: Duration.seconds(60),\n      unit: Unit.NONE,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the number of times the source transitioned from connected to disconnected.\n   *\n   * Emits the `SourceDisconnections` metric with dimension `FlowARN`.\n   *\n   * @default - sum over 60 seconds\n   */\n  public metricSourceDisconnections(props?: MetricOptions): Metric {\n    return this.metric('SourceDisconnections', {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.COUNT,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the number of packets lost during transit, measured before any error\n   * correction takes place.\n   *\n   * Emits the `SourceDroppedPackets` metric with dimension `FlowARN`.\n   *\n   * @default - sum over 60 seconds\n   */\n  public metricSourceDroppedPackets(props?: MetricOptions): Metric {\n    return this.metric('SourceDroppedPackets', {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.COUNT,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the percentage of packets lost during transit, even if they were recovered.\n   *\n   * Emits the `SourcePacketLossPercent` metric with dimension `FlowARN`.\n   *\n   * @default - average over 60 seconds\n   */\n  public metricSourcePacketLossPercent(props?: MetricOptions): Metric {\n    return this.metric('SourcePacketLossPercent', {\n      statistic: 'avg',\n      period: Duration.seconds(60),\n      unit: Unit.PERCENT,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the round-trip time between the source and MediaConnect. Applies only to\n   * RIST, Zixi, and SRT sources.\n   *\n   * Emits the `SourceRoundTripTime` metric with dimension `FlowARN`.\n   *\n   * @default - average over 60 seconds\n   */\n  public metricSourceRoundTripTime(props?: MetricOptions): Metric {\n    return this.metric('SourceRoundTripTime', {\n      statistic: 'avg',\n      period: Duration.seconds(60),\n      unit: Unit.MILLISECONDS,\n      ...props,\n    });\n  }\n\n  /**\n   * Metric for the current network jitter of the source, measured in milliseconds.\n   *\n   * Emits the `SourceJitter` metric with dimension `FlowARN`.\n   *\n   * @default - average over 60 seconds\n   */\n  public metricSourceJitter(props?: MetricOptions): Metric {\n    return this.metric('SourceJitter', {\n      statistic: 'avg',\n      period: Duration.seconds(60),\n      unit: Unit.MILLISECONDS,\n      ...props,\n    });\n  }\n}\n\n/**\n * Defines an AWS Elemental MediaConnect Flow.\n */\n@propertyInjectable\nexport class Flow extends FlowBase implements IFlow {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-mediaconnect-alpha.Flow';\n\n  /**\n   * The set of source protocols where the flow opens an IP:port and listens for\n   * upstream content. Determines availability of `sourceIngestIp`, `sourceIngestPort`,\n   * and `sourceIngestUrl`. Maps each protocol to the URL scheme used to construct\n   * the ingest URL.\n   */\n  private static readonly LISTENER_PROTOCOL_SCHEMES: ReadonlyMap<string, string> = new Map([\n    ['rtp', 'rtp'],\n    ['rtp-fec', 'rtp'],\n    ['rist', 'rist'],\n    ['srt-listener', 'srt'],\n    ['zixi-push', 'zixi'],\n  ]);\n\n  private static isListenerStyleProtocol(protocol: string | undefined): boolean {\n    return protocol !== undefined && Flow.LISTENER_PROTOCOL_SCHEMES.has(protocol);\n  }\n\n  public readonly flowArn: string;\n  public readonly sourceArn: string;\n  public readonly egressIp: string;\n  private readonly _sourceIngestIp: string;\n  private readonly _sourceIngestPort: string;\n  private readonly _hasListenerSource: boolean;\n  public readonly flowAvailabilityZone?: string;\n  public readonly isFailoverEnabled?: boolean = false;\n  private vpcInterfaces: CfnFlow.VpcInterfaceProperty[] = [];\n\n  public get sourceIngestIp(): string {\n    if (!this._hasListenerSource) {\n      throw new ValidationError(\n        lit`SourceIngestIpNotAvailableSourceProtocol`,\n        `'sourceIngestIp' is not available on this Flow ${this.node.path}; only listener-style source protocols (RTP, RTP-FEC, RIST, SRT listener, Zixi push) expose a source ingest IP — CDI, JPEG XS, entitlement, gateway bridge, router, and SRT caller sources do not`,\n        this,\n      );\n    }\n    return this._sourceIngestIp;\n  }\n\n  public get sourceIngestPort(): string {\n    if (!this._hasListenerSource) {\n      throw new ValidationError(\n        lit`SourceIngestPortNotAvailableSourceProtocol`,\n        `'sourceIngestPort' is not available on this Flow ${this.node.path}; only listener-style source protocols (RTP, RTP-FEC, RIST, SRT listener, Zixi push) expose a source ingest port — CDI, JPEG XS, entitlement, gateway bridge, router, and SRT caller sources do not`,\n        this,\n      );\n    }\n    return this._sourceIngestPort;\n  }\n\n  public get sourceIngestUrl(): string {\n    if (!this._hasListenerSource) {\n      throw new ValidationError(\n        lit`SourceIngestUrlNotAvailableSourceProtocol`,\n        `'sourceIngestUrl' is not available on this Flow ${this.node.path}; only listener-style source protocols (RTP, RTP-FEC, RIST, SRT listener, Zixi push) expose a source ingest URL — CDI, JPEG XS, entitlement, gateway bridge, router, and SRT caller sources do not`,\n        this,\n      );\n    }\n    return this.computeIngestUrl(this._sourceProtocol, this._sourceIngestIp, this._sourceIngestPort);\n  }\n\n  constructor(scope: Construct, id: string, props: FlowProps) {\n    super(scope, id, {\n      physicalName: props?.flowName ?? Lazy.string({ produce: () => Names.uniqueResourceName(this, { maxLength: 64 }) }),\n    });\n\n    // Validate flow name if provided\n    this.validateName(props);\n\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    // Validate maintenance start hour format\n    if (props.maintenance) {\n      validateMaintenanceTime(props.maintenance.maintenanceStartHour);\n    }\n\n    // Validate source monitoring thresholds and content-quality requirements\n    this.validateMonitoring(props);\n\n    // Validate encoding config video max bitrate range (10-50 Mbps)\n    this.validateEncoding(props);\n\n    // Only iterate a known-concrete vpcInterfaces list; skip tokenized lists to avoid\n    // pushing the token marker into our internal collection.\n    if (props.vpcInterfaces !== undefined && !Token.isUnresolved(props.vpcInterfaces)) {\n      props.vpcInterfaces.forEach(vpc => this.addVpcInterface(vpc));\n    }\n    this.isFailoverEnabled = props.sourceFailoverConfig?._isEnabled ?? false;\n\n    const sourceConfig = props.source._bind(this, Stack.of(this).formatArn({\n      service: 'mediaconnect',\n      resource: 'flow',\n      resourceName: `*:${this.physicalName}`,\n      arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n    }));\n\n    if ((sourceConfig.protocol === SourceProtocol.JPEGXS.value || sourceConfig.protocol === SourceProtocol.CDI.value)\n      && props.flowSize?.value !== FlowSize.LARGE_4X.value) {\n      throw new ValidationError(\n        lit`FlowSizeRequired`,\n        'Flows using JPEG XS and CDI protocols require LARGE_4X flow size; set flowSize to FlowSize.LARGE_4X',\n        this,\n      );\n    }\n\n    // NDI constraints (discovery server limit, protocol conflicts, flow size, source requirements)\n    this.validateNdi(props, sourceConfig);\n\n    // LARGE_4X only supports CDI and JPEG XS protocols\n    if (props.flowSize?.value === FlowSize.LARGE_4X.value\n      && sourceConfig.protocol !== SourceProtocol.JPEGXS.value\n      && sourceConfig.protocol !== SourceProtocol.CDI.value) {\n      throw new ValidationError(\n        lit`FlowSizeLarge4xProtocol`,\n        'LARGE_4X flow size only supports CDI and JPEG XS protocols',\n        this,\n      );\n    }\n\n    // VPC interface EFA-count limit\n    this.validateVpcEfaCount(props);\n\n    const flow = new CfnFlow(this, 'Resource', {\n      name: this.physicalName,\n      source: sourceConfig,\n      availabilityZone: props?.availabilityZone,\n      flowSize: props?.flowSize?.value,\n      maintenance: props?.maintenance ? {\n        maintenanceDay: toTitleCase(props.maintenance.maintenanceDay),\n        maintenanceStartHour: props.maintenance.maintenanceStartHour,\n      } : undefined,\n      mediaStreams: props.mediaStreams ? props.mediaStreams.map(stream => stream._bind()) : undefined,\n      ndiConfig: props.ndiConfig ? {\n        machineName: props.ndiConfig.machineName,\n        ndiState: props.ndiConfig.ndiState,\n        ndiDiscoveryServers: props.ndiConfig.ndiDiscoveryServers?.map(server => ({\n          discoveryServerAddress: server.discoveryServerAddress,\n          discoveryServerPort: server.discoveryServerPort,\n          vpcInterfaceAdapter: server.vpcInterface.name,\n        })),\n      } : undefined,\n      encodingConfig: props.encodingConfig ? {\n        encodingProfile: props.encodingConfig.encodingProfile,\n        videoMaxBitrate: props.encodingConfig.videoMaxBitrate?.toBps(),\n      } : undefined,\n      sourceFailoverConfig: props.sourceFailoverConfig?._bind(),\n      sourceMonitoringConfig: props.sourceMonitoringConfig ? {\n        contentQualityAnalysisState: props.sourceMonitoringConfig.contentQualityAnalysisState,\n        thumbnailState: props.sourceMonitoringConfig.thumbnailState,\n        audioMonitoringSettings: props.sourceMonitoringConfig.silentAudio ? [{\n          silentAudio: {\n            state: props.sourceMonitoringConfig.silentAudio.state,\n            thresholdSeconds: props.sourceMonitoringConfig.silentAudio.threshold.toSeconds(),\n          },\n        }] : undefined,\n        videoMonitoringSettings: props.sourceMonitoringConfig.blackFrames || props.sourceMonitoringConfig.frozenFrames ? [{\n          blackFrames: props.sourceMonitoringConfig.blackFrames ? {\n            state: props.sourceMonitoringConfig.blackFrames.state,\n            thresholdSeconds: props.sourceMonitoringConfig.blackFrames.threshold.toSeconds(),\n          } : undefined,\n          frozenFrames: props.sourceMonitoringConfig.frozenFrames ? {\n            state: props.sourceMonitoringConfig.frozenFrames.state,\n            thresholdSeconds: props.sourceMonitoringConfig.frozenFrames.threshold.toSeconds(),\n          } : undefined,\n        }] : undefined,\n      } : undefined,\n      vpcInterfaces: Lazy.any({ produce: () => this.vpcInterfaces }, { omitEmptyArray: true }),\n    });\n\n    this.flowArn = flow.attrFlowArn;\n    this.sourceArn = flow.attrSourceSourceArn;\n    this.egressIp = flow.attrEgressIp;\n    this._sourceIngestIp = flow.attrSourceIngestIp;\n    this._sourceIngestPort = flow.attrSourceSourceIngestPort;\n    this.flowAvailabilityZone = flow.attrFlowAvailabilityZone;\n    this._ndiState = props.ndiConfig?.ndiState ?? State.DISABLED;\n    this._sourceProtocol = sourceConfig.protocol;\n    this._hasListenerSource = Flow.isListenerStyleProtocol(sourceConfig.protocol);\n\n    this.node.addValidation({\n      validate: () => {\n        const names = this.vpcInterfaces.map(v => v.name).filter(n => !Token.isUnresolved(n));\n        const duplicates = [...new Set(names.filter((n, i) => names.indexOf(n) !== i))];\n        return duplicates.length > 0\n          ? [`VPC interface names must be unique within a flow. Duplicate name(s): ${duplicates.join(', ')}`]\n          : [];\n      },\n    });\n  }\n\n  /** Validate the flow name length and character set, when a concrete value is provided. */\n  private validateName(props: FlowProps): void {\n    if (props.flowName != null && props.flowName !== '' && !Token.isUnresolved(props.flowName)) {\n      if (props.flowName.length > 64) {\n        throw new ValidationError(lit`FlowNameLength`, `Flow name must be between 1 and 64 characters, got ${props.flowName.length}`, this);\n      }\n      if (!/^[a-zA-Z0-9_-]+$/.test(props.flowName)) {\n        throw new ValidationError(lit`FlowNameFormat`, `Flow name must contain only alphanumeric characters, hyphens, and underscores, got '${props.flowName}'`, this);\n      }\n    }\n  }\n\n  /**\n   * Validate source-monitoring thresholds (10-60 seconds) and that the per-metric checks are only\n   * used when content-quality analysis is enabled.\n   */\n  private validateMonitoring(props: FlowProps): void {\n    const monitoring = props.sourceMonitoringConfig;\n    if (monitoring && (monitoring.silentAudio || monitoring.blackFrames || monitoring.frozenFrames)\n      && monitoring.contentQualityAnalysisState !== State.ENABLED) {\n      throw new ValidationError(\n        lit`MonitoringMetricsRequireContentQualityAnalysis`,\n        'silentAudio, blackFrames, and frozenFrames require contentQualityAnalysisState to be State.ENABLED',\n        this,\n      );\n    }\n    if (monitoring?.silentAudio) {\n      const secs = monitoring.silentAudio.threshold.toSeconds();\n      if (secs < 10 || secs > 60) {\n        throw new ValidationError(lit`SilentAudioThresholdRange`, `Silent audio threshold must be between 10 and 60 seconds, got ${secs}`, this);\n      }\n    }\n    if (monitoring?.blackFrames) {\n      const secs = monitoring.blackFrames.threshold.toSeconds();\n      if (secs < 10 || secs > 60) {\n        throw new ValidationError(lit`BlackFramesThresholdRange`, `Black frames threshold must be between 10 and 60 seconds, got ${secs}`, this);\n      }\n    }\n    if (monitoring?.frozenFrames) {\n      const secs = monitoring.frozenFrames.threshold.toSeconds();\n      if (secs < 10 || secs > 60) {\n        throw new ValidationError(lit`FrozenFramesThresholdRange`, `Frozen frames threshold must be between 10 and 60 seconds, got ${secs}`, this);\n      }\n    }\n  }\n\n  /** Validate the encoding config's video max bitrate range (10-50 Mbps). */\n  private validateEncoding(props: FlowProps): void {\n    if (props.encodingConfig?.videoMaxBitrate) {\n      const mbps = props.encodingConfig.videoMaxBitrate.toMbps();\n      if (mbps < 10 || mbps > 50) {\n        throw new ValidationError(\n          lit`EncodingVideoMaxBitrateRange`,\n          `Encoding config videoMaxBitrate must be between 10 and 50 Mbps, got ${mbps}`,\n          this,\n        );\n      }\n    }\n  }\n\n  /**\n   * Validate NDI constraints: discovery-server limit, mutual exclusivity with CDI/JPEG XS, the\n   * required LARGE flow size, and the requirements an NDI source places on the flow.\n   */\n  private validateNdi(props: FlowProps, sourceConfig: CfnFlow.SourceProperty): void {\n    // NDI discovery servers limit (service rejects >3 at deploy time)\n    const discoveryServers = props.ndiConfig?.ndiDiscoveryServers;\n    if (discoveryServers !== undefined && !Token.isUnresolved(discoveryServers) && discoveryServers.length > 3) {\n      throw new ValidationError(\n        lit`NdiMaxDiscoveryServers`,\n        `NDI config supports a maximum of 3 discovery servers, got ${discoveryServers.length}`,\n        this,\n      );\n    }\n\n    // NDI cannot coexist with CDI or JPEG XS — they require different flow sizes\n    if (props.ndiConfig?.ndiState === State.ENABLED\n      && (sourceConfig.protocol === SourceProtocol.CDI.value || sourceConfig.protocol === SourceProtocol.JPEGXS.value)) {\n      throw new ValidationError(\n        lit`NdiCdiConflict`,\n        'NDI cannot be used with CDI or JPEG XS protocols; NDI requires LARGE flow size while CDI and JPEG XS require LARGE_4X',\n        this,\n      );\n    }\n\n    // NDI requires LARGE flow size (not MEDIUM, not LARGE_4X)\n    if (props.ndiConfig?.ndiState === State.ENABLED\n      && props.flowSize?.value !== FlowSize.LARGE.value) {\n      throw new ValidationError(\n        lit`NdiFlowSizeRequired`,\n        'NDI requires LARGE flow size; set flowSize to FlowSize.LARGE',\n        this,\n      );\n    }\n\n    // NDI sources require NDI to be enabled on the flow\n    if (sourceConfig.protocol === SourceProtocol.NDI_SPEED_HQ.value\n      && props.ndiConfig?.ndiState !== State.ENABLED) {\n      throw new ValidationError(\n        lit`NdiSourceRequiresNdiConfig`,\n        'NDI sources require ndiConfig with ndiState set to State.ENABLED',\n        this,\n      );\n    }\n\n    // NDI sources require LARGE flow size\n    if (sourceConfig.protocol === SourceProtocol.NDI_SPEED_HQ.value\n      && props.flowSize?.value !== FlowSize.LARGE.value) {\n      throw new ValidationError(\n        lit`NdiSourceFlowSizeRequired`,\n        'NDI sources require LARGE flow size; set flowSize to FlowSize.LARGE',\n        this,\n      );\n    }\n\n    // NDI sources require encodingConfig to transcode into a transport stream\n    if (sourceConfig.protocol === SourceProtocol.NDI_SPEED_HQ.value\n      && !props.encodingConfig) {\n      throw new ValidationError(\n        lit`NdiSourceRequiresEncodingConfig`,\n        'NDI sources require encodingConfig to transcode the NDI source into a transport stream',\n        this,\n      );\n    }\n  }\n\n  /** Validate the EFA VPC-interface count (at most one), when the list is concrete. */\n  private validateVpcEfaCount(props: FlowProps): void {\n    // Skip EFA-count validation when the user passed a tokenized vpcInterfaces list;\n    // we can't inspect individual entries in that case.\n    const efaCount = props.vpcInterfaces !== undefined && !Token.isUnresolved(props.vpcInterfaces)\n      ? props.vpcInterfaces.filter(vpc => vpc.networkInterfaceType?.value === NetworkInterface.EFA.value).length\n      : 0;\n\n    if (efaCount > 1) {\n      throw new ValidationError(\n        lit`FlowMaxEfaInterfaces`,\n        `A flow can have a maximum of 1 EFA VPC interface, got ${efaCount}`,\n        this,\n      );\n    }\n  }\n\n  /**\n   * Build the URL for a listener-style source protocol. The caller must have already\n   * checked `_hasListenerSource`; this method assumes the protocol is in\n   * `LISTENER_PROTOCOL_SCHEMES` and throws an unscoped error otherwise.\n   */\n  private computeIngestUrl(protocol: string | undefined, ip: string, port: string): string {\n    const scheme = protocol === undefined ? undefined : Flow.LISTENER_PROTOCOL_SCHEMES.get(protocol);\n    if (scheme === undefined) {\n      throw new UnscopedValidationError(\n        lit`SourceIngestUrlComputeNotListener`,\n        `internal: computeIngestUrl called for non-listener protocol '${protocol}'`,\n      );\n    }\n    return Fn.join('', [`${scheme}://`, ip, ':', port]);\n  }\n\n  /**\n   * Add a VPC interface to this flow.\n   */\n  @MethodMetadata()\n  public addVpcInterface(vpc: VpcInterfaceConfig) {\n    this.vpcInterfaces.push({\n      name: vpc.name,\n      networkInterfaceIds: vpc.networkInterfaceIds,\n      networkInterfaceType: vpc.networkInterfaceType?.value,\n      securityGroupIds: vpc.securityGroups.map(sg => sg.securityGroupId),\n      subnetId: vpc.subnet.subnetId,\n      roleArn: vpc.role.roleArn,\n    });\n    return vpc;\n  }\n}\n"]}