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

package/lib/flow-source-configuration.js

@@ -0,0 +1,595 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceConfiguration = exports.SourceProtocol = exports.NetworkConfiguration = exports.Encoding = 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 helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+const shared_1 = require("./shared");
+/**
+ * Encoding options
+ */
+class Encoding {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.Encoding", version: "2.263.0-alpha.0" };
+    /**
+     * Option for JXSV
+     */
+    static JXSV = new Encoding('jxsv');
+    /**
+     * Option for raw
+     */
+    static RAW = new Encoding('raw');
+    /**
+     * Option for SMPTE-291
+     */
+    static SMPTE291 = new Encoding('smpte291');
+    /**
+     * Option for PCM
+     */
+    static PCM = new Encoding('pcm');
+    /**
+     * Use a custom encoding value
+     * @param value The encoding string value
+     */
+    static of(value) {
+        return new Encoding(value);
+    }
+    /**
+     * @param value The encoding string value
+     */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.Encoding = Encoding;
+/**
+ * Defines network configuration for a source — either a public network with a CIDR allowlist, or a VPC interface.
+ */
+class NetworkConfiguration {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.NetworkConfiguration", version: "2.263.0-alpha.0" };
+    /**
+     * Use a public network with a CIDR allowlist.
+     */
+    static publicNetwork(allowlistCidr) {
+        return new NetworkConfiguration(allowlistCidr, undefined);
+    }
+    /**
+     * Use a VPC interface.
+     */
+    static vpc(vpcInterface) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_VpcInterfaceConfig(vpcInterface);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.vpc);
+            }
+            throw error;
+        }
+        return new NetworkConfiguration(undefined, vpcInterface.name);
+    }
+    /**
+     * The CIDR allowlist for public internet sources, or undefined if using VPC.
+     */
+    allowlistCidr;
+    /**
+     * The VPC interface name, or undefined if using public internet.
+     */
+    vpcInterfaceName;
+    constructor(allowlistCidr, vpcInterfaceName) {
+        this.allowlistCidr = allowlistCidr;
+        this.vpcInterfaceName = vpcInterfaceName;
+    }
+}
+exports.NetworkConfiguration = NetworkConfiguration;
+/**
+ * Protocol Options for Sources
+ */
+class SourceProtocol {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.SourceProtocol", version: "2.263.0-alpha.0" };
+    /**
+     * Options for Zixi Push
+     */
+    static ZIXI_PUSH = new SourceProtocol('zixi-push');
+    /**
+     * Options for RTP-FEC
+     */
+    static RTP_FEC = new SourceProtocol('rtp-fec');
+    /**
+     * Options for RTP
+     */
+    static RTP = new SourceProtocol('rtp');
+    /**
+     * Options for RIST
+     */
+    static RIST = new SourceProtocol('rist');
+    /**
+     * Options for SRT Listener
+     */
+    static SRT_LISTENER = new SourceProtocol('srt-listener');
+    /**
+     * Options for SRT Caller
+     */
+    static SRT_CALLER = new SourceProtocol('srt-caller');
+    /**
+     * Options for 2110
+     */
+    static JPEGXS = new SourceProtocol('st2110-jpegxs');
+    /**
+     * Options for CDI
+     */
+    static CDI = new SourceProtocol('cdi');
+    /**
+     * Options for NDI (SpeedHQ)
+     */
+    static NDI_SPEED_HQ = new SourceProtocol('ndi-speed-hq');
+    /**
+     * Use a custom source protocol value
+     * @param value The source protocol string value
+     */
+    static of(value) {
+        return new SourceProtocol(value);
+    }
+    /**
+     * @param value The source protocol string value
+     */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.SourceProtocol = SourceProtocol;
+/**
+ * Validate a source ingest port is in the allowed range 1024-65535.
+ * Skips the check when the port is tokenized.
+ * @internal
+ */
+function validateIngestPort(port) {
+    if (aws_cdk_lib_1.Token.isUnresolved(port))
+        return;
+    if (port < 1024 || port > 65535) {
+        throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `IngestPortRange`, `Ingest port must be between 1024 and 65535, got ${port}`);
+    }
+}
+/**
+ * Configurations for sources
+ */
+class SourceConfiguration {
+    input;
+    staticKeyDecryption;
+    srtPasswordDecryption;
+    routerDecryption;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.SourceConfiguration", version: "2.263.0-alpha.0" };
+    /**
+     * The source configuration for flows receiving a stream from router.
+     */
+    static router(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_RouterSource(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.router);
+            }
+            throw error;
+        }
+        return new SourceConfiguration({
+            name: input?.routerOutput?.routerOutputName,
+            routerIntegrationState: shared_1.State.ENABLED,
+        }, undefined, undefined, input?.decryption);
+    }
+    /**
+     * The source configuration for cloud flows receiving a stream from a bridge.
+     */
+    static gatewayBridge(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_GatewayBridgeSource(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.gatewayBridge);
+            }
+            throw error;
+        }
+        return new SourceConfiguration({
+            gatewayBridgeSource: {
+                bridgeArn: input.bridge.bridgeArn,
+                vpcInterfaceAttachment: input.vpcInterface ? {
+                    vpcInterfaceName: input.vpcInterface.name,
+                } : undefined,
+            },
+        });
+    }
+    /**
+     * The entitlement that allows you to subscribe to content that comes from another AWS account. The entitlement is set by the
+     * content originator and the ARN is generated as part of the originator's flow.
+     *
+     * @remarks The entitlement must be imported using `FlowEntitlement.fromFlowEntitlementArn()`
+     * as entitlements are created by the content originator in a different AWS account.
+     */
+    static entitlement(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_EntitlementSource(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.entitlement);
+            }
+            throw error;
+        }
+        return new SourceConfiguration({
+            entitlementArn: input.entitlement.entitlementArn,
+        }, input.decryption);
+    }
+    /**
+     * Source option for RTP input
+     */
+    static rtp(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SourceRtp(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rtp);
+            }
+            throw error;
+        }
+        validateIngestPort(input.port);
+        return new SourceConfiguration({
+            name: input.flowSourceName,
+            description: input.description,
+            ingestPort: input.port,
+            protocol: SourceProtocol.RTP.value,
+            whitelistCidr: input.network.allowlistCidr,
+            vpcInterfaceName: input.network.vpcInterfaceName,
+            maxBitrate: input.maxBitrate?.toBps(),
+        });
+    }
+    /**
+     * Source option for RTP-FEC input
+     */
+    static rtpFec(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SourceRtp(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rtpFec);
+            }
+            throw error;
+        }
+        validateIngestPort(input.port);
+        return new SourceConfiguration({
+            name: input.flowSourceName,
+            description: input.description,
+            ingestPort: input.port,
+            protocol: SourceProtocol.RTP_FEC.value,
+            whitelistCidr: input.network.allowlistCidr,
+            vpcInterfaceName: input.network.vpcInterfaceName,
+            maxBitrate: input.maxBitrate?.toBps(),
+        });
+    }
+    /**
+     * Source option for RIST input
+     */
+    static rist(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SourceRist(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rist);
+            }
+            throw error;
+        }
+        validateIngestPort(input.port);
+        return new SourceConfiguration({
+            name: input.flowSourceName,
+            description: input.description,
+            ingestPort: input.port,
+            protocol: SourceProtocol.RIST.value,
+            whitelistCidr: input.network.allowlistCidr,
+            vpcInterfaceName: input.network.vpcInterfaceName,
+            maxLatency: input.maxLatency?.toMilliseconds(),
+            maxBitrate: input.maxBitrate?.toBps(),
+        });
+    }
+    /**
+     * Source option for SRT Listener input
+     */
+    static srtListener(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SourceSrtListener(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.srtListener);
+            }
+            throw error;
+        }
+        validateIngestPort(input.port);
+        if (!aws_cdk_lib_1.Token.isUnresolved(input.port) && (input.port === 2077 || input.port === 2088)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `SrtReservedPort`, `Ports 2077 and 2088 are reserved and cannot be used for SRT Listener, got ${input.port}`);
+        }
+        return new SourceConfiguration({
+            name: input.flowSourceName,
+            description: input.description,
+            ingestPort: input.port,
+            protocol: SourceProtocol.SRT_LISTENER.value,
+            whitelistCidr: input.network.allowlistCidr,
+            vpcInterfaceName: input.network.vpcInterfaceName,
+            minLatency: input.minLatency?.toMilliseconds(),
+            maxBitrate: input.maxBitrate?.toBps(),
+        }, undefined, input.decryption);
+    }
+    /**
+     * Source option for Zixi Push input
+     */
+    static zixiPush(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SourceZixiPush(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.zixiPush);
+            }
+            throw error;
+        }
+        return new SourceConfiguration({
+            name: input.flowSourceName,
+            description: input.description,
+            // Zixi Push ingest port is service-assigned. Standard (public) sources use
+            // port 2088; VPC sources are auto-assigned a port in 2090-2099 and reject
+            // any explicit ingestPort value. Only set the port for the public case.
+            // @see https://docs.aws.amazon.com/mediaconnect/latest/ug/source-ports.html
+            ingestPort: input.network.vpcInterfaceName !== undefined ? undefined : 2088,
+            protocol: SourceProtocol.ZIXI_PUSH.value,
+            whitelistCidr: input.network.allowlistCidr,
+            vpcInterfaceName: input.network.vpcInterfaceName,
+            streamId: input.streamId,
+            maxLatency: input.maxLatency?.toMilliseconds(),
+        }, input.decryption);
+    }
+    /**
+     * Source option for SRT Caller input
+     */
+    static srtCaller(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SourceSrtCaller(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.srtCaller);
+            }
+            throw error;
+        }
+        if (!aws_cdk_lib_1.Token.isUnresolved(input.sourceListenerPort) && (input.sourceListenerPort < 1024 || input.sourceListenerPort > 65535)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `SourceListenerPortRange`, `Source listener port must be between 1024 and 65535, got ${input.sourceListenerPort}`);
+        }
+        if (!aws_cdk_lib_1.Token.isUnresolved(input.sourceListenerPort) && (input.sourceListenerPort === 2077 || input.sourceListenerPort === 2088)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `SrtReservedPort`, `Ports 2077 and 2088 are reserved and cannot be used for SRT Caller, got ${input.sourceListenerPort}`);
+        }
+        return new SourceConfiguration({
+            name: input.flowSourceName,
+            description: input.description,
+            sourceListenerAddress: input.sourceListenerAddress,
+            sourceListenerPort: input.sourceListenerPort,
+            protocol: SourceProtocol.SRT_CALLER.value,
+            vpcInterfaceName: input.vpcInterface?.name,
+            streamId: input.streamId,
+            maxLatency: input.maxLatency?.toMilliseconds(),
+            minLatency: input.minLatency?.toMilliseconds(),
+            maxBitrate: input.maxBitrate?.toBps(),
+        }, undefined, input.decryption);
+    }
+    /**
+     * Source option for CDI input
+     */
+    static cdi(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SourceCdi(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.cdi);
+            }
+            throw error;
+        }
+        validateIngestPort(input.port);
+        if (input.maxSyncBuffer !== undefined
+            && !aws_cdk_lib_1.Token.isUnresolved(input.maxSyncBuffer)
+            && (input.maxSyncBuffer < 0 || input.maxSyncBuffer > 250)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `MaxSyncBufferRange`, `Max sync buffer must be between 0 and 250, got ${input.maxSyncBuffer}`);
+        }
+        // Validate CDI requires EFA interface
+        if (input.vpcInterface.networkInterfaceType?.value !== shared_1.NetworkInterface.EFA.value) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `CdiRequiresEfa`, 'CDI protocol requires an EFA network interface type');
+        }
+        return new SourceConfiguration({
+            name: input.flowSourceName,
+            ingestPort: input.port,
+            // CDI requires MaxSyncBuffer at the service level. When omitted, default to
+            // 100 ms — matches the MediaConnect console default and avoids a deploy-time error.
+            maxSyncBuffer: input.maxSyncBuffer ?? 100,
+            protocol: SourceProtocol.CDI.value,
+            vpcInterfaceName: input.vpcInterface?.name,
+            mediaStreamSourceConfigurations: input.mediaStreamSourceConfigurations.map(inputStreamSource => {
+                return {
+                    encodingName: inputStreamSource.encoding.value,
+                    mediaStreamName: inputStreamSource.mediaStream._bind().mediaStreamName,
+                };
+            }),
+        });
+    }
+    /**
+     * Source option for Jpeg-XS input
+     */
+    static jpegXs(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SourceJpegXs(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.jpegXs);
+            }
+            throw error;
+        }
+        jpegXsValidation(input);
+        return new SourceConfiguration({
+            name: input.flowSourceName,
+            // JPEG XS, like CDI, requires MaxSyncBuffer at the service level. Default to
+            // 100 ms when omitted — matches the MediaConnect console default.
+            maxSyncBuffer: input.maxSyncBuffer ?? 100,
+            protocol: SourceProtocol.JPEGXS.value,
+            mediaStreamSourceConfigurations: parseJpegXsMediaStreamConfigurationFields(input.mediaStreamSourceConfigurations),
+        });
+    }
+    /**
+     * Source option for NDI (SpeedHQ) input.
+     *
+     * The flow must be configured with `flowSize: FlowSize.LARGE` and
+     * `ndiConfig.ndiState = State.ENABLED` with at least one NDI discovery server.
+     */
+    static ndi(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SourceNdi(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.ndi);
+            }
+            throw error;
+        }
+        const { sourceName } = input;
+        return new SourceConfiguration({
+            name: input.flowSourceName,
+            description: input.description,
+            protocol: SourceProtocol.NDI_SPEED_HQ.value,
+            ndiSourceSettings: sourceName ? { sourceName } : undefined,
+        });
+    }
+    /**
+     * The name of this source, if one was set on the configuration.
+     */
+    flowSourceName;
+    /**
+     * @param input - CFN-shaped source properties (encryption fields are merged in `_bind`).
+     * @param staticKeyDecryption - Optional static-key decryption. Set at most one of
+     *   `staticKeyDecryption` / `srtPasswordDecryption`.
+     * @param srtPasswordDecryption - Optional SRT-password decryption.
+     * @param routerDecryption - Optional transit decryption for router integration.
+     */
+    constructor(input, staticKeyDecryption, srtPasswordDecryption, routerDecryption) {
+        this.input = input;
+        this.staticKeyDecryption = staticKeyDecryption;
+        this.srtPasswordDecryption = srtPasswordDecryption;
+        this.routerDecryption = routerDecryption;
+        this.flowSourceName = input.name;
+    }
+    /**
+     * Called when the source configuration is bound to a Flow or FlowSource.
+     * @param scope    Construct used as scope for any auto-created sub-constructs (encryption role, etc.)
+     * @param flowArn  Optional ARN of the consuming flow — when provided, scopes any
+     *                 auto-created encryption role's trust policy to that flow.
+     * @internal
+     */
+    _bind(scope, flowArn) {
+        const cidr = this.input.whitelistCidr;
+        if (cidr !== undefined && !aws_cdk_lib_1.Token.isUnresolved(cidr) && (0, shared_1.isOpenCidr)(cidr)) {
+            aws_cdk_lib_1.Annotations.of(scope).addWarningV2('@aws-cdk/aws-mediaconnect-alpha:openSourceCidr', `Source CIDR allowlist '${cidr}' allows traffic from any IP. Restrict to the narrowest range your source can send from.`);
+        }
+        return {
+            ...this.input,
+            decryption: this.renderDecryption(scope, flowArn),
+            routerIntegrationTransitDecryption: this.input.routerIntegrationState === shared_1.State.ENABLED
+                ? (0, shared_1.renderTransitEncryption)(scope, 'RouterTransitDecryptionRole', this.routerDecryption, flowArn)
+                : undefined,
+        };
+    }
+    renderDecryption(scope, flowArn) {
+        if (this.staticKeyDecryption)
+            return (0, shared_1.renderStaticKeyEncryption)(scope, this.staticKeyDecryption, flowArn);
+        if (this.srtPasswordDecryption)
+            return (0, shared_1.renderSrtPasswordEncryption)(scope, this.srtPasswordDecryption, flowArn);
+        return undefined;
+    }
+}
+exports.SourceConfiguration = SourceConfiguration;
+/**
+ * Validation for JPEGXS configuration
+ * @param input SourceJpegXs configuration
+ */
+function jpegXsValidation(input) {
+    if (input.maxSyncBuffer !== undefined
+        && !aws_cdk_lib_1.Token.isUnresolved(input.maxSyncBuffer)
+        && (input.maxSyncBuffer < 0 || input.maxSyncBuffer > 250)) {
+        throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `MaxSyncBufferRange`, `Max sync buffer must be between 0 and 250, got ${input.maxSyncBuffer}`);
+    }
+    // Skip structural validation when the whole list is tokenized — we can't
+    // iterate it, and any per-element validation below assumes real values.
+    if (aws_cdk_lib_1.Token.isUnresolved(input.mediaStreamSourceConfigurations))
+        return;
+    // Validate exactly 2 input configurations per media stream for JPEG XS
+    input.mediaStreamSourceConfigurations.forEach((config) => {
+        if (!config.inputInterface || config.inputInterface.length !== 2) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `JpegXsInputInterfaceCount`, 'JPEG XS protocol requires exactly 2 input configurations per media stream source configuration, ' +
+                `media stream '${config.mediaStream._bind().mediaStreamName}' has ${config.inputInterface?.length ?? 0}`);
+        }
+    });
+    const usedPorts = new Set();
+    input.mediaStreamSourceConfigurations.forEach((config) => {
+        if (usedPorts.has(config.port)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `DuplicateMediaStreamPort`, `Each media stream must use a unique port, port ${config.port} is used by multiple media streams`);
+        }
+        usedPorts.add(config.port);
+    });
+    let efaCount = 0;
+    input.mediaStreamSourceConfigurations.forEach(config => {
+        config.inputInterface.forEach(iface => {
+            if (iface.networkInterfaceType?.value === shared_1.NetworkInterface.EFA.value) {
+                efaCount++;
+            }
+        });
+    });
+    if (efaCount > 1) {
+        throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `JpegXsMaxEfaInterfaces`, `JPEG XS flows can have a maximum of 1 EFA VPC interface, got ${efaCount}`);
+    }
+    // Validate that the 2 input interfaces are different
+    input.mediaStreamSourceConfigurations.forEach((config) => {
+        if (config.inputInterface[0] === config.inputInterface[1]) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `JpegXsDuplicateInterface`, `The 2 input interfaces for media stream '${config.mediaStream._bind().mediaStreamName}' must be different VPC interfaces`);
+        }
+    });
+    // Validate at most 1 video media stream
+    const videoStreams = input.mediaStreamSourceConfigurations.filter(config => config.mediaStream._bind().mediaStreamType === 'video');
+    if (videoStreams.length > 1) {
+        throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `MaxVideoStreams`, `A source may reference at most one video media stream, got ${videoStreams.length}`);
+    }
+}
+/**
+ * Helper function to parse media stream configuration fields
+ */
+function parseJpegXsMediaStreamConfigurationFields(mediaStreamConfig) {
+    if (!mediaStreamConfig)
+        return undefined;
+    return mediaStreamConfig.map(config => ({
+        encodingName: config.encoding.value,
+        inputConfigurations: config.inputInterface?.map(inputInterface => ({
+            inputPort: config.port,
+            interface: {
+                name: inputInterface.name,
+            },
+        })),
+        mediaStreamName: config.mediaStream._bind().mediaStreamName,
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-source-configuration.js","sourceRoot":"","sources":["flow-source-configuration.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Bitrate, Duration } from 'aws-cdk-lib';\nimport { Annotations, Token, UnscopedValidationError } from 'aws-cdk-lib';\nimport type { CfnFlow } from 'aws-cdk-lib/aws-mediaconnect';\nimport { lit } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport type { Construct } from 'constructs';\nimport type { IBridge } from './bridge';\nimport type { MediaStream } from './flow';\nimport type { IFlowEntitlement } from './flow-entitlement';\nimport type { IRouterOutput } from './router-output';\nimport type { SrtPasswordEncryption, StaticKeyEncryption, TransitEncryption, VpcInterfaceConfig } from './shared';\nimport { NetworkInterface, State, isOpenCidr, renderSrtPasswordEncryption, renderStaticKeyEncryption, renderTransitEncryption } from './shared';\n\n/**\n * Encoding options\n */\nexport class Encoding {\n  /**\n   * Option for JXSV\n   */\n  public static readonly JXSV = new Encoding('jxsv');\n  /**\n   * Option for raw\n   */\n  public static readonly RAW = new Encoding('raw');\n  /**\n   * Option for SMPTE-291\n   */\n  public static readonly SMPTE291 = new Encoding('smpte291');\n  /**\n   * Option for PCM\n   */\n  public static readonly PCM = new Encoding('pcm');\n\n  /**\n   * Use a custom encoding value\n   * @param value The encoding string value\n   */\n  public static of(value: string): Encoding {\n    return new Encoding(value);\n  }\n\n  /**\n   * @param value The encoding string value\n   */\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 * Defines network configuration for a source — either a public network with a CIDR allowlist, or a VPC interface.\n */\nexport class NetworkConfiguration {\n  /**\n   * Use a public network with a CIDR allowlist.\n   */\n  public static publicNetwork(allowlistCidr: string): NetworkConfiguration {\n    return new NetworkConfiguration(allowlistCidr, undefined);\n  }\n\n  /**\n   * Use a VPC interface.\n   */\n  public static vpc(vpcInterface: VpcInterfaceConfig): NetworkConfiguration {\n    return new NetworkConfiguration(undefined, vpcInterface.name);\n  }\n\n  /**\n   * The CIDR allowlist for public internet sources, or undefined if using VPC.\n   */\n  public readonly allowlistCidr?: string;\n\n  /**\n   * The VPC interface name, or undefined if using public internet.\n   */\n  public readonly vpcInterfaceName?: string;\n\n  private constructor(allowlistCidr?: string, vpcInterfaceName?: string) {\n    this.allowlistCidr = allowlistCidr;\n    this.vpcInterfaceName = vpcInterfaceName;\n  }\n}\n\n/**\n * Options for Media Stream Source Configuration\n */\nexport interface MediaStreamSourceConfigurationCdi {\n  /**\n   * The format that was used to encode the data. For ancillary data streams, set the encoding name to smpte291.\n   * If the encoding name is smpte291, set the color space to one of the following:\n   * BT601, BT709, BT2020, or BT2100. For all other ancillary data streams, set the color space to SDR-NOCOLOR.\n   */\n  readonly encoding: Encoding;\n  /**\n   * The name of the media stream.\n   */\n  readonly mediaStream: MediaStream;\n}\n\n/**\n * Options for Media Stream Source Configuration\n */\nexport interface MediaStreamSourceConfigurationJpegXs {\n  /**\n   * The format that was used to encode the data. For ancillary data streams, set the encoding name to smpte291.\n   * If the encoding name is smpte291, set the color space to one of the following:\n   * BT601, BT709, BT2020, or BT2100. For all other ancillary data streams, set the color space to SDR-NOCOLOR.\n   */\n  readonly encoding: Encoding;\n  /**\n   * The port that the flow listens on for this incoming media stream.\n   */\n  readonly port: number;\n  /**\n   * The VPC interfaces where the media stream comes in from.\n   */\n  readonly inputInterface: VpcInterfaceConfig[];\n  /**\n   * The name of the media stream.\n   */\n  readonly mediaStream: MediaStream;\n}\n\n/**\n * Common configuration across all inputs\n */\nexport interface SourceBase {\n  /**\n   * The name of the source.\n   *\n   * @default - a name is generated automatically\n   */\n  readonly flowSourceName?: string;\n  /**\n   * A description of the source. This description appears only on the MediaConnect console and will not be seen by the end user.\n   *\n   * @default - no description\n   */\n  readonly description?: string;\n}\n\n/**\n * Configuration for RTP\n */\nexport interface SourceRtp extends SourceBase {\n  /**\n   * The port that the flow will be listening on for incoming content.\n   */\n  readonly port: number;\n  /**\n   * The maximum bitrate for RIST, RTP, and RTP-FEC streams.\n   *\n   * @default - no maximum bitrate\n   */\n  readonly maxBitrate?: Bitrate;\n  /**\n   * Defines networking configuration\n   */\n  readonly network: NetworkConfiguration;\n}\n\n/**\n * Configuration for RIST\n */\nexport interface SourceRist extends SourceBase {\n  /**\n   * The maximum latency in milliseconds for a RIST or Zixi-based source.\n   *\n   * @default - undefined; when omitted, MediaConnect applies its service default maximum latency\n   */\n  readonly maxLatency?: Duration;\n  /**\n   * The port that the flow will be listening on for incoming content.\n   */\n  readonly port: number;\n  /**\n   * The maximum bitrate for RIST, RTP, and RTP-FEC streams.\n   *\n   * @default - no maximum bitrate\n   */\n  readonly maxBitrate?: Bitrate;\n  /**\n   * Defines networking configuration\n   */\n  readonly network: NetworkConfiguration;\n}\n\n/**\n * Configuration for SRT Listener\n */\nexport interface SourceSrtListener extends SourceBase {\n  /**\n   * The port that the flow listens on for incoming content.\n   *\n   * Valid range: 1024–65535. Ports 2077 and 2088 are reserved by MediaConnect for Zixi\n   * traffic and cannot be used for SRT Listener.\n   */\n  readonly port: number;\n  /**\n   * The maximum bitrate for streams.\n   *\n   * @default - no maximum bitrate\n   */\n  readonly maxBitrate?: Bitrate;\n  /**\n   * Defines networking configuration\n   */\n  readonly network: NetworkConfiguration;\n  /**\n   * The minimum latency in milliseconds for SRT-based streams. The value you set on your\n   * MediaConnect source represents the minimal potential latency of that connection. The\n   * latency of the stream is set to the higher of the sender's minimum latency and the\n   * receiver's minimum latency.\n   *\n   * @default - no minimum latency\n   */\n  readonly minLatency?: Duration;\n\n  /**\n   * SRT Decryption options\n   *\n   * @default - no decryption\n   */\n  readonly decryption?: SrtPasswordEncryption;\n}\n\n/**\n * Configuration for SRT Caller\n */\nexport interface SourceSrtCaller extends SourceBase {\n  /**\n   * Source IP or domain name for SRT-caller protocol.\n   */\n  readonly sourceListenerAddress: string;\n  /**\n   * Source port for SRT-caller protocol.\n   *\n   * Valid range: 1024–65535. Ports 2077 and 2088 are reserved by MediaConnect for Zixi\n   * traffic and cannot be used for SRT Caller.\n   */\n  readonly sourceListenerPort: number;\n  /**\n   * The maximum bitrate for streams.\n   *\n   * @default - no maximum bitrate\n   */\n  readonly maxBitrate?: Bitrate;\n  /**\n   * The maximum latency in milliseconds for SRT-based streams.\n   *\n   * @default - no maximum latency\n   */\n  readonly maxLatency?: Duration;\n  /**\n   * The minimum latency in milliseconds for SRT-based streams. The value you set on your\n   * MediaConnect source represents the minimal potential latency of that connection. The\n   * latency of the stream is set to the higher of the sender's minimum latency and the\n   * receiver's minimum latency.\n   *\n   * @default - no minimum latency\n   */\n  readonly minLatency?: Duration;\n  /**\n   * The stream ID that you want to use for the transport.\n   *\n   * @default - no stream ID\n   */\n  readonly streamId?: string;\n  /**\n   * Optional VPC interface for the outbound SRT Caller connection. SRT Caller initiates\n   * the connection to the configured `sourceListenerAddress` and `sourceListenerPort`,\n   * so no CIDR allow list is needed.\n   *\n   * @default - outbound connection via the public internet; no VPC interface\n   */\n  readonly vpcInterface?: VpcInterfaceConfig;\n\n  /**\n   * SRT Decryption options\n   *\n   * @default - no decryption\n   */\n  readonly decryption?: SrtPasswordEncryption;\n}\n\n/**\n * Configuration for Zixi Push.\n *\n * No port option is exposed: MediaConnect assigns the Zixi Push ingest port itself —\n * public sources are served on 2088, VPC sources are auto-assigned a port in 2090–2099.\n * The service rejects any user-supplied port value, so the L2 surface doesn't accept one.\n *\n * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/source-ports.html\n */\nexport interface SourceZixiPush extends SourceBase {\n  /**\n   * The maximum latency in milliseconds for a Zixi-based source.\n   *\n   * @default - chosen by MediaConnect\n   */\n  readonly maxLatency?: Duration;\n  /**\n   * The stream ID that you want to use for the transport. This parameter applies only to Zixi-based streams.\n   *\n   * @default - no stream ID\n   */\n  readonly streamId?: string;\n  /**\n   * Defines networking configuration\n   */\n  readonly network: NetworkConfiguration;\n  /**\n   * Decrypt source with static keys\n   *\n   * @default - no decryption\n   */\n  readonly decryption?: StaticKeyEncryption;\n}\n\n/**\n * Configuration for CDI\n */\nexport interface SourceCdi {\n  /**\n   * The name of the source.\n   *\n   * @default - a name is generated automatically\n   */\n  readonly flowSourceName?: string;\n  /**\n   * The VPC interface attachment to use for this bridge source.\n   */\n  readonly vpcInterface: VpcInterfaceConfig;\n  /**\n   * The size of the buffer (in ms) to use to sync incoming source data.\n   *\n   * Required by the MediaConnect service for CDI sources.\n   */\n  readonly maxSyncBuffer: number;\n  /**\n   * The port that the flow will be listening on for incoming content.\n   */\n  readonly port: number;\n  /**\n   * The media stream that is associated with the source, and the parameters for that association.\n   */\n  readonly mediaStreamSourceConfigurations: MediaStreamSourceConfigurationCdi[];\n}\n\n/**\n * Configuration for Jpeg XS\n */\nexport interface SourceJpegXs {\n  /**\n   * The name of the source.\n   *\n   * @default - a name is generated automatically\n   */\n  readonly flowSourceName?: string;\n  /**\n   * The size of the buffer (in ms) to use to sync incoming source data.\n   *\n   * @default 100\n   */\n  readonly maxSyncBuffer?: number;\n  /**\n   * The media stream that is associated with the source, and the parameters for that association.\n   */\n  readonly mediaStreamSourceConfigurations: MediaStreamSourceConfigurationJpegXs[];\n  /**\n   * The VPC interface attachment to use for this bridge source.\n   *\n   * @default - no VPC interface\n   */\n  readonly vpcInterface?: VpcInterfaceConfig[];\n}\n\n/**\n * Configuration for NDI (SpeedHQ) source.\n *\n * NDI sources are ingested from NDI senders inside your VPC. The flow must be\n * configured with `flowSize: FlowSize.LARGE` and `ndiConfig.ndiState = ENABLED`\n * with at least one NDI discovery server. The VPC connectivity for NDI is\n * configured on the discovery server entries in `NdiConfig`, not on the source\n * itself.\n */\nexport interface SourceNdi {\n  /**\n   * The name of the source.\n   *\n   * @default - a name is generated automatically\n   */\n  readonly flowSourceName?: string;\n\n  /**\n   * A description of the source. This description appears only on the MediaConnect\n   * console and will not be seen by the end user.\n   *\n   * @default - no description\n   */\n  readonly description?: string;\n\n  /**\n   * The exact name of an existing NDI sender that's registered with your discovery\n   * server. If included, the format of this name must be `MACHINENAME (ProgramName)`.\n   *\n   * If not specified, you can select the upstream NDI sender from the console\n   * after starting the flow.\n   *\n   * @default - select the NDI sender after starting the flow\n   */\n  readonly sourceName?: string;\n}\n\n/**\n * Options for Gateway Bridge Source\n */\nexport interface GatewayBridgeSource {\n  /**\n   * The bridge feeding this flow.\n   */\n  readonly bridge: IBridge;\n  /**\n   * The VPC interface attachment to use for this bridge source.\n   *\n   * @default - no VPC interface\n   */\n  readonly vpcInterface?: VpcInterfaceConfig;\n}\n\n/**\n * Options for Router Source\n */\nexport interface RouterSource {\n  /**\n   * The router output that feeds this flow source.\n   *\n   * @default - no router output connected\n   */\n  readonly routerOutput?: IRouterOutput;\n  /**\n   * Options to decrypt incoming feed\n   *\n   * @default - no decryption\n   */\n  readonly decryption?: TransitEncryption;\n}\n\n/**\n * Options for Entitlement\n */\nexport interface EntitlementSource {\n  /**\n   * The entitlement that allows you to subscribe to content that comes from another AWS account.\n   *\n   * @remarks Entitlements are always imported from another AWS account using\n   * `FlowEntitlement.fromFlowEntitlementArn()`. You cannot create new entitlements\n   * in the same stack where you're consuming them.\n   */\n  readonly entitlement: IFlowEntitlement;\n  /**\n   * Options to decrypt incoming feed\n   *\n   * @default - no decryption\n   */\n  readonly decryption?: StaticKeyEncryption;\n}\n\n/**\n * Protocol Options for Sources\n */\nexport class SourceProtocol {\n  /**\n   * Options for Zixi Push\n   */\n  public static readonly ZIXI_PUSH = new SourceProtocol('zixi-push');\n  /**\n   * Options for RTP-FEC\n   */\n  public static readonly RTP_FEC = new SourceProtocol('rtp-fec');\n  /**\n   * Options for RTP\n   */\n  public static readonly RTP = new SourceProtocol('rtp');\n  /**\n   * Options for RIST\n   */\n  public static readonly RIST = new SourceProtocol('rist');\n  /**\n   * Options for SRT Listener\n   */\n  public static readonly SRT_LISTENER = new SourceProtocol('srt-listener');\n  /**\n   * Options for SRT Caller\n   */\n  public static readonly SRT_CALLER = new SourceProtocol('srt-caller');\n  /**\n   * Options for 2110\n   */\n  public static readonly JPEGXS = new SourceProtocol('st2110-jpegxs');\n  /**\n   * Options for CDI\n   */\n  public static readonly CDI = new SourceProtocol('cdi');\n  /**\n   * Options for NDI (SpeedHQ)\n   */\n  public static readonly NDI_SPEED_HQ = new SourceProtocol('ndi-speed-hq');\n\n  /**\n   * Use a custom source protocol value\n   * @param value The source protocol string value\n   */\n  public static of(value: string): SourceProtocol {\n    return new SourceProtocol(value);\n  }\n\n  /**\n   * @param value The source protocol string value\n   */\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 * Validate a source ingest port is in the allowed range 1024-65535.\n * Skips the check when the port is tokenized.\n * @internal\n */\nfunction validateIngestPort(port: number): void {\n  if (Token.isUnresolved(port)) return;\n  if (port < 1024 || port > 65535) {\n    throw new UnscopedValidationError(lit`IngestPortRange`, `Ingest port must be between 1024 and 65535, got ${port}`);\n  }\n}\n\n/**\n * Configurations for sources\n */\nexport class SourceConfiguration {\n  /**\n   * The source configuration for flows receiving a stream from router.\n   */\n  public static router(input?: RouterSource): SourceConfiguration {\n    return new SourceConfiguration({\n      name: input?.routerOutput?.routerOutputName,\n      routerIntegrationState: State.ENABLED,\n    }, undefined, undefined, input?.decryption);\n  }\n\n  /**\n   * The source configuration for cloud flows receiving a stream from a bridge.\n   */\n  public static gatewayBridge(input: GatewayBridgeSource): SourceConfiguration {\n    return new SourceConfiguration({\n      gatewayBridgeSource: {\n        bridgeArn: input.bridge.bridgeArn,\n        vpcInterfaceAttachment: input.vpcInterface ? {\n          vpcInterfaceName: input.vpcInterface.name,\n        } : undefined,\n      },\n    });\n  }\n\n  /**\n   * The entitlement that allows you to subscribe to content that comes from another AWS account. The entitlement is set by the\n   * content originator and the ARN is generated as part of the originator's flow.\n   *\n   * @remarks The entitlement must be imported using `FlowEntitlement.fromFlowEntitlementArn()`\n   * as entitlements are created by the content originator in a different AWS account.\n   */\n  public static entitlement(input: EntitlementSource): SourceConfiguration {\n    return new SourceConfiguration({\n      entitlementArn: input.entitlement.entitlementArn,\n    }, input.decryption);\n  }\n\n  /**\n   * Source option for RTP input\n   */\n  public static rtp(input: SourceRtp): SourceConfiguration {\n    validateIngestPort(input.port);\n\n    return new SourceConfiguration({\n      name: input.flowSourceName,\n      description: input.description,\n      ingestPort: input.port,\n      protocol: SourceProtocol.RTP.value,\n      whitelistCidr: input.network.allowlistCidr,\n      vpcInterfaceName: input.network.vpcInterfaceName,\n      maxBitrate: input.maxBitrate?.toBps(),\n    });\n  }\n\n  /**\n   * Source option for RTP-FEC input\n   */\n  public static rtpFec(input: SourceRtp): SourceConfiguration {\n    validateIngestPort(input.port);\n\n    return new SourceConfiguration({\n      name: input.flowSourceName,\n      description: input.description,\n      ingestPort: input.port,\n      protocol: SourceProtocol.RTP_FEC.value,\n      whitelistCidr: input.network.allowlistCidr,\n      vpcInterfaceName: input.network.vpcInterfaceName,\n      maxBitrate: input.maxBitrate?.toBps(),\n    });\n  }\n\n  /**\n   * Source option for RIST input\n   */\n  public static rist(input: SourceRist): SourceConfiguration {\n    validateIngestPort(input.port);\n\n    return new SourceConfiguration({\n      name: input.flowSourceName,\n      description: input.description,\n      ingestPort: input.port,\n      protocol: SourceProtocol.RIST.value,\n      whitelistCidr: input.network.allowlistCidr,\n      vpcInterfaceName: input.network.vpcInterfaceName,\n      maxLatency: input.maxLatency?.toMilliseconds(),\n      maxBitrate: input.maxBitrate?.toBps(),\n    });\n  }\n\n  /**\n   * Source option for SRT Listener input\n   */\n  public static srtListener(input: SourceSrtListener): SourceConfiguration {\n    validateIngestPort(input.port);\n    if (!Token.isUnresolved(input.port) && (input.port === 2077 || input.port === 2088)) {\n      throw new UnscopedValidationError(lit`SrtReservedPort`, `Ports 2077 and 2088 are reserved and cannot be used for SRT Listener, got ${input.port}`);\n    }\n\n    return new SourceConfiguration({\n      name: input.flowSourceName,\n      description: input.description,\n      ingestPort: input.port,\n      protocol: SourceProtocol.SRT_LISTENER.value,\n      whitelistCidr: input.network.allowlistCidr,\n      vpcInterfaceName: input.network.vpcInterfaceName,\n      minLatency: input.minLatency?.toMilliseconds(),\n      maxBitrate: input.maxBitrate?.toBps(),\n    }, undefined, input.decryption);\n  }\n\n  /**\n   * Source option for Zixi Push input\n   */\n  public static zixiPush(input: SourceZixiPush): SourceConfiguration {\n    return new SourceConfiguration({\n      name: input.flowSourceName,\n      description: input.description,\n      // Zixi Push ingest port is service-assigned. Standard (public) sources use\n      // port 2088; VPC sources are auto-assigned a port in 2090-2099 and reject\n      // any explicit ingestPort value. Only set the port for the public case.\n      // @see https://docs.aws.amazon.com/mediaconnect/latest/ug/source-ports.html\n      ingestPort: input.network.vpcInterfaceName !== undefined ? undefined : 2088,\n      protocol: SourceProtocol.ZIXI_PUSH.value,\n      whitelistCidr: input.network.allowlistCidr,\n      vpcInterfaceName: input.network.vpcInterfaceName,\n      streamId: input.streamId,\n      maxLatency: input.maxLatency?.toMilliseconds(),\n    }, input.decryption);\n  }\n\n  /**\n   * Source option for SRT Caller input\n   */\n  public static srtCaller(input: SourceSrtCaller): SourceConfiguration {\n    if (!Token.isUnresolved(input.sourceListenerPort) && (input.sourceListenerPort < 1024 || input.sourceListenerPort > 65535)) {\n      throw new UnscopedValidationError(lit`SourceListenerPortRange`, `Source listener port must be between 1024 and 65535, got ${input.sourceListenerPort}`);\n    }\n    if (!Token.isUnresolved(input.sourceListenerPort) && (input.sourceListenerPort === 2077 || input.sourceListenerPort === 2088)) {\n      throw new UnscopedValidationError(lit`SrtReservedPort`, `Ports 2077 and 2088 are reserved and cannot be used for SRT Caller, got ${input.sourceListenerPort}`);\n    }\n\n    return new SourceConfiguration({\n      name: input.flowSourceName,\n      description: input.description,\n      sourceListenerAddress: input.sourceListenerAddress,\n      sourceListenerPort: input.sourceListenerPort,\n      protocol: SourceProtocol.SRT_CALLER.value,\n      vpcInterfaceName: input.vpcInterface?.name,\n      streamId: input.streamId,\n      maxLatency: input.maxLatency?.toMilliseconds(),\n      minLatency: input.minLatency?.toMilliseconds(),\n      maxBitrate: input.maxBitrate?.toBps(),\n    }, undefined, input.decryption);\n  }\n\n  /**\n   * Source option for CDI input\n   */\n  public static cdi(input: SourceCdi): SourceConfiguration {\n    validateIngestPort(input.port);\n    if (input.maxSyncBuffer !== undefined\n      && !Token.isUnresolved(input.maxSyncBuffer)\n      && (input.maxSyncBuffer < 0 || input.maxSyncBuffer > 250)) {\n      throw new UnscopedValidationError(lit`MaxSyncBufferRange`, `Max sync buffer must be between 0 and 250, got ${input.maxSyncBuffer}`);\n    }\n\n    // Validate CDI requires EFA interface\n    if (input.vpcInterface.networkInterfaceType?.value !== NetworkInterface.EFA.value) {\n      throw new UnscopedValidationError(\n        lit`CdiRequiresEfa`,\n        'CDI protocol requires an EFA network interface type',\n      );\n    }\n\n    return new SourceConfiguration({\n      name: input.flowSourceName,\n      ingestPort: input.port,\n      // CDI requires MaxSyncBuffer at the service level. When omitted, default to\n      // 100 ms — matches the MediaConnect console default and avoids a deploy-time error.\n      maxSyncBuffer: input.maxSyncBuffer ?? 100,\n      protocol: SourceProtocol.CDI.value,\n      vpcInterfaceName: input.vpcInterface?.name,\n      mediaStreamSourceConfigurations: input.mediaStreamSourceConfigurations.map(inputStreamSource => {\n        return {\n          encodingName: inputStreamSource.encoding.value,\n          mediaStreamName: inputStreamSource.mediaStream._bind().mediaStreamName,\n        };\n      }),\n    });\n  }\n\n  /**\n   * Source option for Jpeg-XS input\n   */\n  public static jpegXs(input: SourceJpegXs): SourceConfiguration {\n    jpegXsValidation(input);\n\n    return new SourceConfiguration({\n      name: input.flowSourceName,\n      // JPEG XS, like CDI, requires MaxSyncBuffer at the service level. Default to\n      // 100 ms when omitted — matches the MediaConnect console default.\n      maxSyncBuffer: input.maxSyncBuffer ?? 100,\n      protocol: SourceProtocol.JPEGXS.value,\n      mediaStreamSourceConfigurations: parseJpegXsMediaStreamConfigurationFields(input.mediaStreamSourceConfigurations),\n    });\n  }\n\n  /**\n   * Source option for NDI (SpeedHQ) input.\n   *\n   * The flow must be configured with `flowSize: FlowSize.LARGE` and\n   * `ndiConfig.ndiState = State.ENABLED` with at least one NDI discovery server.\n   */\n  public static ndi(input: SourceNdi): SourceConfiguration {\n    const { sourceName } = input;\n    return new SourceConfiguration({\n      name: input.flowSourceName,\n      description: input.description,\n      protocol: SourceProtocol.NDI_SPEED_HQ.value,\n      ndiSourceSettings: sourceName ? { sourceName } : undefined,\n    });\n  }\n\n  /**\n   * The name of this source, if one was set on the configuration.\n   */\n  public readonly flowSourceName?: string;\n\n  /**\n   * @param input - CFN-shaped source properties (encryption fields are merged in `_bind`).\n   * @param staticKeyDecryption - Optional static-key decryption. Set at most one of\n   *   `staticKeyDecryption` / `srtPasswordDecryption`.\n   * @param srtPasswordDecryption - Optional SRT-password decryption.\n   * @param routerDecryption - Optional transit decryption for router integration.\n   */\n  private constructor(\n    private readonly input: CfnFlow.SourceProperty,\n    private readonly staticKeyDecryption?: StaticKeyEncryption,\n    private readonly srtPasswordDecryption?: SrtPasswordEncryption,\n    private readonly routerDecryption?: TransitEncryption,\n  ) {\n    this.flowSourceName = input.name;\n  }\n\n  /**\n   * Called when the source configuration is bound to a Flow or FlowSource.\n   * @param scope    Construct used as scope for any auto-created sub-constructs (encryption role, etc.)\n   * @param flowArn  Optional ARN of the consuming flow — when provided, scopes any\n   *                 auto-created encryption role's trust policy to that flow.\n   * @internal\n   */\n  public _bind(scope: Construct, flowArn?: string): CfnFlow.SourceProperty {\n    const cidr = this.input.whitelistCidr;\n    if (cidr !== undefined && !Token.isUnresolved(cidr) && isOpenCidr(cidr)) {\n      Annotations.of(scope).addWarningV2(\n        '@aws-cdk/aws-mediaconnect-alpha:openSourceCidr',\n        `Source CIDR allowlist '${cidr}' allows traffic from any IP. Restrict to the narrowest range your source can send from.`,\n      );\n    }\n    return {\n      ...this.input,\n      decryption: this.renderDecryption(scope, flowArn),\n      routerIntegrationTransitDecryption: this.input.routerIntegrationState === State.ENABLED\n        ? renderTransitEncryption(scope, 'RouterTransitDecryptionRole', this.routerDecryption, flowArn)\n        : undefined,\n    };\n  }\n\n  private renderDecryption(scope: Construct, flowArn?: string): CfnFlow.EncryptionProperty | undefined {\n    if (this.staticKeyDecryption) return renderStaticKeyEncryption(scope, this.staticKeyDecryption, flowArn);\n    if (this.srtPasswordDecryption) return renderSrtPasswordEncryption(scope, this.srtPasswordDecryption, flowArn);\n    return undefined;\n  }\n}\n\n/**\n * Validation for JPEGXS configuration\n * @param input SourceJpegXs configuration\n */\nfunction jpegXsValidation(input: SourceJpegXs) {\n  if (input.maxSyncBuffer !== undefined\n    && !Token.isUnresolved(input.maxSyncBuffer)\n    && (input.maxSyncBuffer < 0 || input.maxSyncBuffer > 250)) {\n    throw new UnscopedValidationError(lit`MaxSyncBufferRange`, `Max sync buffer must be between 0 and 250, got ${input.maxSyncBuffer}`);\n  }\n\n  // Skip structural validation when the whole list is tokenized — we can't\n  // iterate it, and any per-element validation below assumes real values.\n  if (Token.isUnresolved(input.mediaStreamSourceConfigurations)) return;\n\n  // Validate exactly 2 input configurations per media stream for JPEG XS\n  input.mediaStreamSourceConfigurations.forEach((config) => {\n    if (!config.inputInterface || config.inputInterface.length !== 2) {\n      throw new UnscopedValidationError(\n        lit`JpegXsInputInterfaceCount`,\n        'JPEG XS protocol requires exactly 2 input configurations per media stream source configuration, ' +\n        `media stream '${config.mediaStream._bind().mediaStreamName}' has ${config.inputInterface?.length ?? 0}`,\n      );\n    }\n  });\n\n  const usedPorts = new Set<number>();\n  input.mediaStreamSourceConfigurations.forEach((config) => {\n    if (usedPorts.has(config.port)) {\n      throw new UnscopedValidationError(\n        lit`DuplicateMediaStreamPort`,\n        `Each media stream must use a unique port, port ${config.port} is used by multiple media streams`,\n      );\n    }\n    usedPorts.add(config.port);\n  });\n\n  let efaCount = 0;\n  input.mediaStreamSourceConfigurations.forEach(config => {\n    config.inputInterface.forEach(iface => {\n      if (iface.networkInterfaceType?.value === NetworkInterface.EFA.value) {\n        efaCount++;\n      }\n    });\n  });\n  if (efaCount > 1) {\n    throw new UnscopedValidationError(\n      lit`JpegXsMaxEfaInterfaces`,\n      `JPEG XS flows can have a maximum of 1 EFA VPC interface, got ${efaCount}`,\n    );\n  }\n\n  // Validate that the 2 input interfaces are different\n  input.mediaStreamSourceConfigurations.forEach((config) => {\n    if (config.inputInterface[0] === config.inputInterface[1]) {\n      throw new UnscopedValidationError(\n        lit`JpegXsDuplicateInterface`,\n        `The 2 input interfaces for media stream '${config.mediaStream._bind().mediaStreamName}' must be different VPC interfaces`,\n      );\n    }\n  });\n\n  // Validate at most 1 video media stream\n  const videoStreams = input.mediaStreamSourceConfigurations.filter(\n    config => config.mediaStream._bind().mediaStreamType === 'video',\n  );\n\n  if (videoStreams.length > 1) {\n    throw new UnscopedValidationError(\n      lit`MaxVideoStreams`,\n      `A source may reference at most one video media stream, got ${videoStreams.length}`,\n    );\n  }\n}\n\n/**\n * Helper function to parse media stream configuration fields\n */\nfunction parseJpegXsMediaStreamConfigurationFields(mediaStreamConfig?: MediaStreamSourceConfigurationJpegXs[]):\n  CfnFlow.MediaStreamSourceConfigurationProperty[] | undefined {\n  if (!mediaStreamConfig) return undefined;\n  return mediaStreamConfig.map(config => ({\n    encodingName: config.encoding.value,\n    inputConfigurations: config.inputInterface?.map(inputInterface => ({\n      inputPort: config.port,\n      interface: {\n        name: inputInterface.name,\n      },\n    })),\n    mediaStreamName: config.mediaStream._bind().mediaStreamName,\n  }));\n}\n"]}