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

package/lib/flow-output.js

@@ -0,0 +1,415 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowOutput = exports.OutputConfiguration = 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_mediaconnect_1 = require("aws-cdk-lib/aws-mediaconnect");
+const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+const prop_injectable_1 = require("aws-cdk-lib/core/lib/prop-injectable");
+const shared_1 = require("./shared");
+/**
+ * Flow output protocol options.
+ */
+var FlowOutputProtocol;
+(function (FlowOutputProtocol) {
+    /**
+     * ZIXI_PUSH option
+     */
+    FlowOutputProtocol["ZIXI_PUSH"] = "zixi-push";
+    /**
+     * RTP_FEC option
+     */
+    FlowOutputProtocol["RTP_FEC"] = "rtp-fec";
+    /**
+     * RTP option
+     */
+    FlowOutputProtocol["RTP"] = "rtp";
+    /**
+     * ZIXI_PULL option
+     */
+    FlowOutputProtocol["ZIXI_PULL"] = "zixi-pull";
+    /**
+     * RIST option
+     */
+    FlowOutputProtocol["RIST"] = "rist";
+    /**
+     * SRT_LISTENER option
+     */
+    FlowOutputProtocol["SRT_LISTENER"] = "srt-listener";
+    /**
+     * SRT_CALLER option
+     */
+    FlowOutputProtocol["SRT_CALLER"] = "srt-caller";
+    /**
+     * NDI option
+     */
+    FlowOutputProtocol["NDI"] = "ndi-speed-hq";
+})(FlowOutputProtocol || (FlowOutputProtocol = {}));
+/**
+ * Configuration options to define a FlowOutput by protocol.
+ */
+class OutputConfiguration {
+    _output;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.OutputConfiguration", 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_RouterTransitConfig(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.router);
+            }
+            throw error;
+        }
+        return new OutputConfiguration({
+            routerIntegrationState: shared_1.State.ENABLED,
+            routerIntegrationTransitEncryption: input?.encryption,
+        });
+    }
+    /**
+     * Option for RTP configuration
+     */
+    static rtp(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_RtpOutputConfig(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rtp);
+            }
+            throw error;
+        }
+        return new OutputConfiguration({
+            protocol: FlowOutputProtocol.RTP,
+            destination: input.destination,
+            port: input.port,
+            smoothingLatency: input.smoothingLatency?.toMilliseconds(),
+            vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),
+        });
+    }
+    /**
+     * Option for RTP-FEC configuration
+     */
+    static rtpFec(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_RtpFecOutputConfig(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rtpFec);
+            }
+            throw error;
+        }
+        return new OutputConfiguration({
+            protocol: FlowOutputProtocol.RTP_FEC,
+            destination: input.destination,
+            port: input.port,
+            smoothingLatency: input.smoothingLatency?.toMilliseconds(),
+            vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),
+        });
+    }
+    /**
+     * Option for RIST configuration
+     */
+    static rist(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_RistOutputConfig(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rist);
+            }
+            throw error;
+        }
+        return new OutputConfiguration({
+            protocol: FlowOutputProtocol.RIST,
+            destination: input.destination,
+            port: input.port,
+            smoothingLatency: input.smoothingLatency?.toMilliseconds(),
+            vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),
+        });
+    }
+    /**
+     * Option for Zixi Push configuration
+     */
+    static zixiPush(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_ZixiPushOutputConfig(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.zixiPush);
+            }
+            throw error;
+        }
+        return new OutputConfiguration({
+            protocol: FlowOutputProtocol.ZIXI_PUSH,
+            destination: input.destination,
+            port: input.port,
+            streamId: input.streamId,
+            maxLatency: input.maxLatency.toMilliseconds(),
+            cidrAllowList: input.cidrAllowList,
+            staticKeyEncryption: input.encryption,
+            vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),
+        });
+    }
+    /**
+     * Option for Zixi Pull configuration
+     */
+    static zixiPull(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_ZixiPullOutputConfig(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.zixiPull);
+            }
+            throw error;
+        }
+        return new OutputConfiguration({
+            protocol: FlowOutputProtocol.ZIXI_PULL,
+            streamId: input.streamId,
+            remoteId: input.remoteId,
+            maxLatency: input.maxLatency.toMilliseconds(),
+            cidrAllowList: input.cidrAllowList,
+            staticKeyEncryption: input.encryption,
+            vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),
+        });
+    }
+    /**
+     * Option for SRT Caller configuration
+     */
+    static srtCaller(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SrtCallerOutputConfig(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.srtCaller);
+            }
+            throw error;
+        }
+        return new OutputConfiguration({
+            protocol: FlowOutputProtocol.SRT_CALLER,
+            destination: input.destination,
+            port: input.port,
+            minLatency: input.minLatency?.toMilliseconds(),
+            streamId: input.streamId,
+            srtPasswordEncryption: input.encryption,
+            vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),
+        });
+    }
+    /**
+     * Option for SRT Listener configuration
+     */
+    static srtListener(input) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_SrtListenerOutputConfig(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.srtListener);
+            }
+            throw error;
+        }
+        return new OutputConfiguration({
+            protocol: FlowOutputProtocol.SRT_LISTENER,
+            port: input.port,
+            minLatency: input.minLatency?.toMilliseconds(),
+            cidrAllowList: input.cidrAllowList,
+            srtPasswordEncryption: input.encryption,
+            vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),
+        });
+    }
+    /**
+     * Option for NDI configuration
+     */
+    static ndi(input = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_NdiOutputConfig(input);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.ndi);
+            }
+            throw error;
+        }
+        if (input.ndiSpeedHqQuality !== undefined
+            && !aws_cdk_lib_1.Token.isUnresolved(input.ndiSpeedHqQuality)
+            && (input.ndiSpeedHqQuality < 100 || input.ndiSpeedHqQuality > 200)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `NdiSpeedHqQualityRange`, `NDI Speed HQ quality must be between 100 and 200, got ${input.ndiSpeedHqQuality}`);
+        }
+        return new OutputConfiguration({
+            protocol: FlowOutputProtocol.NDI,
+            ndiProgramName: input.ndiProgramName,
+            ndiSpeedHqQuality: input.ndiSpeedHqQuality,
+        });
+    }
+    /**
+     * @param output - Configuration for outputs in output
+     */
+    constructor(_output) {
+        this._output = _output;
+    }
+    /**
+     * Called when the output configuration is bound to a FlowOutput.
+     * @internal
+     */
+    _bind() {
+        return { ...this._output };
+    }
+}
+exports.OutputConfiguration = OutputConfiguration;
+/**
+ * Shared base for both real and imported flow outputs.
+ * @internal
+ */
+class FlowOutputBase extends aws_cdk_lib_1.Resource {
+    get flowOutputRef() {
+        return { outputArn: this.flowOutputArn };
+    }
+}
+/**
+ * Resource defines the destination address, protocol, and port that
+ * AWS Elemental MediaConnect sends the ingested video to.
+ */
+let FlowOutput = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = FlowOutputBase;
+    var FlowOutput = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            FlowOutput = _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.FlowOutput", version: "2.263.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-mediaconnect-alpha.FlowOutput';
+        /**
+         * Creates a Flow Ouput construct that represents an external (imported) Flow Output.
+         */
+        static fromFlowOutputArn(scope, id, flowOutputArn) {
+            class Import extends FlowOutputBase {
+                flowOutputArn = flowOutputArn;
+            }
+            return new Import(scope, id);
+        }
+        flowOutputArn;
+        constructor(scope, id, props) {
+            super(scope, id, {
+                physicalName: props?.flowOutputName ?? aws_cdk_lib_1.Lazy.string({ produce: () => aws_cdk_lib_1.Names.uniqueResourceName(this, { maxLength: 128 }) }),
+            });
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_FlowOutputProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, FlowOutput);
+                }
+                throw error;
+            }
+            // Validate flow output name if provided
+            if (props.flowOutputName != null && props.flowOutputName !== '' && !aws_cdk_lib_1.Token.isUnresolved(props.flowOutputName)) {
+                if (props.flowOutputName.length > 128) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `FlowOutputNameLength`, `Flow output name must be between 1 and 128 characters, got ${props.flowOutputName.length}`, this);
+                }
+                if (!/^[a-zA-Z0-9-]+$/.test(props.flowOutputName)) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `FlowOutputNameFormat`, `Flow output name must contain only alphanumeric characters and hyphens, got '${props.flowOutputName}'`, this);
+                }
+            }
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            const outputConfig = props.output._bind();
+            // Warn on fully-open CIDR allow lists.
+            if (outputConfig.cidrAllowList !== undefined && !aws_cdk_lib_1.Token.isUnresolved(outputConfig.cidrAllowList)) {
+                for (const cidr of outputConfig.cidrAllowList) {
+                    if (!aws_cdk_lib_1.Token.isUnresolved(cidr) && (0, shared_1.isOpenCidr)(cidr)) {
+                        aws_cdk_lib_1.Annotations.of(this).addWarningV2('@aws-cdk/aws-mediaconnect-alpha:openOutputCidr', `Output CIDR allow list '${cidr}' allows pull requests from any IP. Restrict to the narrowest range your consumers need.`);
+                    }
+                }
+            }
+            const { staticKeyEncryption, srtPasswordEncryption, routerIntegrationTransitEncryption, ...cfnOutputConfig } = outputConfig;
+            const resource = new aws_mediaconnect_1.CfnFlowOutput(this, 'Resource', {
+                ...cfnOutputConfig,
+                encryption: renderOutputEncryption(this, staticKeyEncryption, srtPasswordEncryption, props.flow.flowArn),
+                name: this.physicalName,
+                flowArn: props.flow.flowArn,
+                description: props.description,
+                outputStatus: props.outputStatus,
+                routerIntegrationTransitEncryption: outputConfig.routerIntegrationState === shared_1.State.ENABLED
+                    ? (0, shared_1.renderTransitEncryption)(this, 'RouterTransitEncryptionRole', routerIntegrationTransitEncryption, props.flow.flowArn)
+                    : undefined,
+            });
+            this.flowOutputArn = resource.attrOutputArn;
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return FlowOutput = _classThis;
+})();
+exports.FlowOutput = FlowOutput;
+/**
+ * Resolve the output's key-based encryption (either static-key or SRT-password) to its
+ * CFN shape. At most one of the two encryption fields is set on a given output.
+ */
+function renderOutputEncryption(scope, staticKey, srtPassword, sourceArn) {
+    if (staticKey)
+        return (0, shared_1.renderStaticKeyEncryption)(scope, staticKey, sourceArn);
+    if (srtPassword)
+        return (0, shared_1.renderSrtPasswordEncryption)(scope, srtPassword, sourceArn);
+    return undefined;
+}
+/**
+ * Helper function to parse VPC interface attachment from L2 type to L1 property.
+ */
+function parseVpcInterfaceAttachment(vpcInterface) {
+    if (!vpcInterface)
+        return undefined;
+    return { vpcInterfaceName: vpcInterface.name };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-output.js","sourceRoot":"","sources":["flow-output.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Duration, IResource } from 'aws-cdk-lib';\nimport { Annotations, Lazy, Names, Resource, Token, UnscopedValidationError, ValidationError } from 'aws-cdk-lib';\nimport { CfnFlowOutput } from 'aws-cdk-lib/aws-mediaconnect';\nimport type { IFlowOutputRef, FlowOutputReference } from 'aws-cdk-lib/aws-mediaconnect';\nimport { lit } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport type { Construct } from 'constructs';\nimport type { IFlow } from './flow';\nimport type { SrtPasswordEncryption, StaticKeyEncryption, TransitEncryption, VpcInterfaceConfig } from './shared';\nimport { State, isOpenCidr, renderSrtPasswordEncryption, renderStaticKeyEncryption, renderTransitEncryption } from './shared';\n\n/**\n * Interface for Flow Output\n */\nexport interface IFlowOutput extends IResource, IFlowOutputRef {\n  /**\n   * The Amazon Resource Name (ARN) of the flow output.\n   *\n   * @attribute\n   */\n  readonly flowOutputArn: string;\n}\n\n/**\n * Properties for flow output\n */\nexport interface FlowOutputProps {\n  /**\n   * The name of the output.\n   *\n   * @default - auto-generated\n   */\n  readonly flowOutputName?: string;\n\n  /**\n   * A description of the output.\n   *\n   * 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   * An indication of whether the output should transmit data or not.\n   *\n   * @default - undefined; when omitted, MediaConnect enables the output (ENABLED) at deploy time\n   */\n  readonly outputStatus?: State;\n\n  /**\n   * The flow this output is attached to.\n   */\n  readonly flow: IFlow;\n\n  /**\n   * Output configuration\n   */\n  readonly output: OutputConfiguration;\n}\n\n/**\n * Flow output protocol options.\n */\nenum FlowOutputProtocol {\n  /**\n   * ZIXI_PUSH option\n   */\n  ZIXI_PUSH='zixi-push',\n  /**\n   * RTP_FEC option\n   */\n  RTP_FEC='rtp-fec',\n  /**\n   * RTP option\n   */\n  RTP='rtp',\n  /**\n   * ZIXI_PULL option\n   */\n  ZIXI_PULL='zixi-pull',\n  /**\n   * RIST option\n   */\n  RIST='rist',\n  /**\n   * SRT_LISTENER option\n   */\n  SRT_LISTENER='srt-listener',\n  /**\n   * SRT_CALLER option\n   */\n  SRT_CALLER='srt-caller',\n  /**\n   * NDI option\n   */\n  NDI='ndi-speed-hq',\n}\n\n/**\n * Configuration options for RTP outputs.\n */\nexport interface RtpOutputConfig {\n  /**\n   * The smoothing latency for RIST, RTP, and RTP-FEC streams.\n   *\n   * @default - no smoothing latency\n   */\n  readonly smoothingLatency?: Duration;\n  /**\n   * The IP address where you want to send the output.\n   */\n  readonly destination: string;\n  /**\n   * The port to use when content is distributed to this output.\n   */\n  readonly port: number;\n  /**\n   * The name of the VPC interface attachment to use for this output.\n   *\n   * @default - no VPC interface attachment\n   */\n  readonly vpcInterfaceAttachment?: VpcInterfaceConfig;\n}\n\n/**\n * Configuration options for RTP-FEC outputs.\n */\nexport interface RtpFecOutputConfig extends RtpOutputConfig { }\n/**\n * Configuration options for RIST outputs.\n */\nexport interface RistOutputConfig extends RtpOutputConfig { }\n\n/**\n * Configuration options for Zixi Pull outputs.\n */\nexport interface ZixiPullOutputConfig {\n  /**\n   * The stream ID that you want to use for this transport.\n   */\n  readonly streamId: string;\n  /**\n   * The remote ID for the Zixi-pull stream.\n   */\n  readonly remoteId: string;\n  /**\n   * The maximum latency for Zixi-based streams.\n   */\n  readonly maxLatency: Duration;\n  /**\n   * The range of IP addresses that should be allowed to initiate output requests to this flow.\n   * These IP addresses should be in the form of a Classless Inter-Domain Routing (CIDR) block; for example, 10.0.0.0/16.\n   *\n   * Required by the MediaConnect service for Zixi Pull outputs.\n   */\n  readonly cidrAllowList: string[];\n  /**\n   * Static key encryption for this output.\n   *\n   * @default - no encryption\n   */\n  readonly encryption?: StaticKeyEncryption;\n  /**\n   * The VPC interface attachment to use for this output.\n   *\n   * @default - no VPC interface attachment\n   */\n  readonly vpcInterfaceAttachment?: VpcInterfaceConfig;\n}\n\n/**\n * Configuration options for Zixi Push outputs.\n */\nexport interface ZixiPushOutputConfig {\n  /**\n   * The stream ID that you want to use for this transport.\n   */\n  readonly streamId: string;\n  /**\n   * The maximum latency for Zixi-based streams.\n   */\n  readonly maxLatency: Duration;\n  /**\n   * The range of IP addresses that should be allowed to initiate output requests to this flow.\n   * These IP addresses should be in the form of a Classless Inter-Domain Routing (CIDR) block; for example, 10.0.0.0/16.\n   *\n   * @default - no CIDR allow list\n   */\n  readonly cidrAllowList?: string[];\n  /**\n   * Static key encryption for this output.\n   *\n   * @default - no encryption\n   */\n  readonly encryption?: StaticKeyEncryption;\n  /**\n   * The IP address where you want to send the output.\n   */\n  readonly destination: string;\n  /**\n   * The port to use when content is distributed to this output.\n   */\n  readonly port: number;\n  /**\n   * The VPC interface attachment to use for this output.\n   *\n   * @default - no VPC interface attachment\n   */\n  readonly vpcInterfaceAttachment?: VpcInterfaceConfig;\n}\n\n/**\n * Configuration options for SRT Caller outputs.\n */\nexport interface SrtCallerOutputConfig {\n  /**\n   * The minimum latency in milliseconds for SRT-based streams. The value you set on your\n   * MediaConnect output 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 this transport.\n   *\n   * @default - no stream ID\n   */\n  readonly streamId?: string;\n  /**\n   * The IP address where you want to send the output.\n   */\n  readonly destination: string;\n  /**\n   * The port to use when content is distributed to this output.\n   */\n  readonly port: number;\n  /**\n   * SRT password encryption for this output.\n   *\n   * @default - no encryption\n   */\n  readonly encryption?: SrtPasswordEncryption;\n  /**\n   * The VPC interface attachment to use for this output.\n   *\n   * @default - no VPC interface attachment\n   */\n  readonly vpcInterfaceAttachment?: VpcInterfaceConfig;\n}\n\n/**\n * Configuration options for SRT Listener outputs.\n */\nexport interface SrtListenerOutputConfig {\n  /**\n   * The minimum latency in milliseconds for SRT-based streams. The value you set on your\n   * MediaConnect output 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 port to use when content is distributed to this output.\n   */\n  readonly port: number;\n  /**\n   * The range of IP addresses that should be allowed to initiate output requests to this flow.\n   * These IP addresses should be in the form of a Classless Inter-Domain Routing (CIDR) block; for example, 10.0.0.0/16.\n   *\n   * @default - no CIDR allow list\n   */\n  readonly cidrAllowList?: string[];\n  /**\n   * SRT password encryption for this output.\n   *\n   * @default - no encryption\n   */\n  readonly encryption?: SrtPasswordEncryption;\n  /**\n   * The VPC interface attachment to use for this output.\n   *\n   * @default - no VPC interface attachment\n   */\n  readonly vpcInterfaceAttachment?: VpcInterfaceConfig;\n}\n\n/**\n * Configuration options for NDI outputs.\n */\nexport interface NdiOutputConfig {\n  /**\n   * A suffix for the names of the NDI sources that the flow creates.\n   *\n   * @default - the output name is used\n   */\n  readonly ndiProgramName?: string;\n  /**\n   * A quality setting for the NDI Speed HQ encoder, expressed as a percentage.\n   *\n   * Valid range: 100-200. Higher values produce higher quality and larger bitrate.\n   *\n   * @see https://aws.amazon.com/about-aws/whats-new/2025/03/aws-elemental-mediaconnect-support-ndi-outputs/\n   * @default - the MediaConnect service default\n   */\n  readonly ndiSpeedHqQuality?: number;\n}\n\n/**\n * Internal flow output configuration. CFN-bound fields use L1 property types; encryption\n * fields are kept as L2 classes (resolved to CFN shape in the FlowOutput constructor).\n * @internal\n */\ninterface FlowOutputConfig {\n  readonly cidrAllowList?: string[];\n  readonly destination?: string;\n  /** Static-key encryption for Zixi Pull outputs. Set at most one of these two fields. */\n  readonly staticKeyEncryption?: StaticKeyEncryption;\n  /** SRT-password encryption for SRT outputs. Set at most one of these two fields. */\n  readonly srtPasswordEncryption?: SrtPasswordEncryption;\n  readonly maxLatency?: number;\n  readonly minLatency?: number;\n  readonly ndiProgramName?: string;\n  readonly ndiSpeedHqQuality?: number;\n  readonly port?: number;\n  readonly protocol?: string;\n  readonly remoteId?: string;\n  readonly smoothingLatency?: number;\n  readonly streamId?: string;\n  readonly vpcInterfaceAttachment?: CfnFlowOutput.VpcInterfaceAttachmentProperty;\n  readonly routerIntegrationState?: State;\n  readonly routerIntegrationTransitEncryption?: TransitEncryption;\n}\n\n/**\n * Output configuration to Router\n */\nexport interface RouterTransitConfig {\n  /**\n   * Specifies whether encryption is to be used.\n   *\n   * @default no encryption\n   */\n  readonly encryption?: TransitEncryption;\n}\n\n/**\n * Configuration options to define a FlowOutput by protocol.\n */\nexport class OutputConfiguration {\n  /**\n   * The source configuration for flows receiving a stream from router.\n   */\n  public static router(input?: RouterTransitConfig): OutputConfiguration {\n    return new OutputConfiguration({\n      routerIntegrationState: State.ENABLED,\n      routerIntegrationTransitEncryption: input?.encryption,\n    });\n  }\n\n  /**\n   * Option for RTP configuration\n   */\n  public static rtp(input: RtpOutputConfig): OutputConfiguration {\n    return new OutputConfiguration({\n      protocol: FlowOutputProtocol.RTP,\n      destination: input.destination,\n      port: input.port,\n      smoothingLatency: input.smoothingLatency?.toMilliseconds(),\n      vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),\n    });\n  }\n\n  /**\n   * Option for RTP-FEC configuration\n   */\n  public static rtpFec(input: RtpFecOutputConfig): OutputConfiguration {\n    return new OutputConfiguration({\n      protocol: FlowOutputProtocol.RTP_FEC,\n      destination: input.destination,\n      port: input.port,\n      smoothingLatency: input.smoothingLatency?.toMilliseconds(),\n      vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),\n    });\n  }\n\n  /**\n   * Option for RIST configuration\n   */\n  public static rist(input: RistOutputConfig): OutputConfiguration {\n    return new OutputConfiguration({\n      protocol: FlowOutputProtocol.RIST,\n      destination: input.destination,\n      port: input.port,\n      smoothingLatency: input.smoothingLatency?.toMilliseconds(),\n      vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),\n    });\n  }\n\n  /**\n   * Option for Zixi Push configuration\n   */\n  public static zixiPush(input: ZixiPushOutputConfig): OutputConfiguration {\n    return new OutputConfiguration({\n      protocol: FlowOutputProtocol.ZIXI_PUSH,\n      destination: input.destination,\n      port: input.port,\n      streamId: input.streamId,\n      maxLatency: input.maxLatency.toMilliseconds(),\n      cidrAllowList: input.cidrAllowList,\n      staticKeyEncryption: input.encryption,\n      vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),\n    });\n  }\n\n  /**\n   * Option for Zixi Pull configuration\n   */\n  public static zixiPull(input: ZixiPullOutputConfig): OutputConfiguration {\n    return new OutputConfiguration({\n      protocol: FlowOutputProtocol.ZIXI_PULL,\n      streamId: input.streamId,\n      remoteId: input.remoteId,\n      maxLatency: input.maxLatency.toMilliseconds(),\n      cidrAllowList: input.cidrAllowList,\n      staticKeyEncryption: input.encryption,\n      vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),\n    });\n  }\n\n  /**\n   * Option for SRT Caller configuration\n   */\n  public static srtCaller(input: SrtCallerOutputConfig): OutputConfiguration {\n    return new OutputConfiguration({\n      protocol: FlowOutputProtocol.SRT_CALLER,\n      destination: input.destination,\n      port: input.port,\n      minLatency: input.minLatency?.toMilliseconds(),\n      streamId: input.streamId,\n      srtPasswordEncryption: input.encryption,\n      vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),\n    });\n  }\n\n  /**\n   * Option for SRT Listener configuration\n   */\n  public static srtListener(input: SrtListenerOutputConfig): OutputConfiguration {\n    return new OutputConfiguration({\n      protocol: FlowOutputProtocol.SRT_LISTENER,\n      port: input.port,\n      minLatency: input.minLatency?.toMilliseconds(),\n      cidrAllowList: input.cidrAllowList,\n      srtPasswordEncryption: input.encryption,\n      vpcInterfaceAttachment: parseVpcInterfaceAttachment(input.vpcInterfaceAttachment),\n    });\n  }\n\n  /**\n   * Option for NDI configuration\n   */\n  public static ndi(input: NdiOutputConfig = {}): OutputConfiguration {\n    if (input.ndiSpeedHqQuality !== undefined\n      && !Token.isUnresolved(input.ndiSpeedHqQuality)\n      && (input.ndiSpeedHqQuality < 100 || input.ndiSpeedHqQuality > 200)) {\n      throw new UnscopedValidationError(\n        lit`NdiSpeedHqQualityRange`,\n        `NDI Speed HQ quality must be between 100 and 200, got ${input.ndiSpeedHqQuality}`,\n      );\n    }\n\n    return new OutputConfiguration({\n      protocol: FlowOutputProtocol.NDI,\n      ndiProgramName: input.ndiProgramName,\n      ndiSpeedHqQuality: input.ndiSpeedHqQuality,\n    });\n  }\n\n  /**\n   * @param output - Configuration for outputs in output\n   */\n  private constructor(private readonly _output: FlowOutputConfig) { }\n\n  /**\n   * Called when the output configuration is bound to a FlowOutput.\n   * @internal\n   */\n  public _bind(): FlowOutputConfig {\n    return { ...this._output };\n  }\n}\n\n/**\n * Shared base for both real and imported flow outputs.\n * @internal\n */\nabstract class FlowOutputBase extends Resource implements IFlowOutput {\n  public abstract readonly flowOutputArn: string;\n\n  public get flowOutputRef(): FlowOutputReference {\n    return { outputArn: this.flowOutputArn };\n  }\n}\n\n/**\n * Resource defines the destination address, protocol, and port that\n * AWS Elemental MediaConnect sends the ingested video to.\n */\n@propertyInjectable\nexport class FlowOutput extends FlowOutputBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-mediaconnect-alpha.FlowOutput';\n\n  /**\n   * Creates a Flow Ouput construct that represents an external (imported) Flow Output.\n   */\n  public static fromFlowOutputArn(scope: Construct, id: string, flowOutputArn: string): IFlowOutput {\n    class Import extends FlowOutputBase {\n      public readonly flowOutputArn = flowOutputArn;\n    }\n\n    return new Import(scope, id);\n  }\n\n  public readonly flowOutputArn: string;\n\n  constructor(scope: Construct, id: string, props: FlowOutputProps) {\n    super(scope, id, {\n      physicalName: props?.flowOutputName ?? Lazy.string({ produce: () => Names.uniqueResourceName(this, { maxLength: 128 }) }),\n    });\n\n    // Validate flow output name if provided\n    if (props.flowOutputName != null && props.flowOutputName !== '' && !Token.isUnresolved(props.flowOutputName)) {\n      if (props.flowOutputName.length > 128) {\n        throw new ValidationError(lit`FlowOutputNameLength`, `Flow output name must be between 1 and 128 characters, got ${props.flowOutputName.length}`, this);\n      }\n      if (!/^[a-zA-Z0-9-]+$/.test(props.flowOutputName)) {\n        throw new ValidationError(lit`FlowOutputNameFormat`, `Flow output name must contain only alphanumeric characters and hyphens, got '${props.flowOutputName}'`, this);\n      }\n    }\n\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    const outputConfig = props.output._bind();\n\n    // Warn on fully-open CIDR allow lists.\n    if (outputConfig.cidrAllowList !== undefined && !Token.isUnresolved(outputConfig.cidrAllowList)) {\n      for (const cidr of outputConfig.cidrAllowList) {\n        if (!Token.isUnresolved(cidr) && isOpenCidr(cidr)) {\n          Annotations.of(this).addWarningV2(\n            '@aws-cdk/aws-mediaconnect-alpha:openOutputCidr',\n            `Output CIDR allow list '${cidr}' allows pull requests from any IP. Restrict to the narrowest range your consumers need.`,\n          );\n        }\n      }\n    }\n    const { staticKeyEncryption, srtPasswordEncryption, routerIntegrationTransitEncryption, ...cfnOutputConfig } = outputConfig;\n\n    const resource = new CfnFlowOutput(this, 'Resource', {\n      ...cfnOutputConfig,\n      encryption: renderOutputEncryption(this, staticKeyEncryption, srtPasswordEncryption, props.flow.flowArn),\n      name: this.physicalName,\n      flowArn: props.flow.flowArn,\n      description: props.description,\n      outputStatus: props.outputStatus,\n      routerIntegrationTransitEncryption: outputConfig.routerIntegrationState === State.ENABLED\n        ? renderTransitEncryption(this, 'RouterTransitEncryptionRole', routerIntegrationTransitEncryption, props.flow.flowArn)\n        : undefined,\n    });\n\n    this.flowOutputArn = resource.attrOutputArn;\n  }\n}\n\n/**\n * Resolve the output's key-based encryption (either static-key or SRT-password) to its\n * CFN shape. At most one of the two encryption fields is set on a given output.\n */\nfunction renderOutputEncryption(\n  scope: Construct,\n  staticKey: StaticKeyEncryption | undefined,\n  srtPassword: SrtPasswordEncryption | undefined,\n  sourceArn?: string,\n): CfnFlowOutput.EncryptionProperty | undefined {\n  if (staticKey) return renderStaticKeyEncryption(scope, staticKey, sourceArn);\n  if (srtPassword) return renderSrtPasswordEncryption(scope, srtPassword, sourceArn);\n  return undefined;\n}\n\n/**\n * Helper function to parse VPC interface attachment from L2 type to L1 property.\n */\nfunction parseVpcInterfaceAttachment(vpcInterface?: VpcInterfaceConfig): CfnFlowOutput.VpcInterfaceAttachmentProperty | undefined {\n  if (!vpcInterface) return undefined;\n  return { vpcInterfaceName: vpcInterface.name };\n}\n\n"]}