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

package/lib/shared.js

@@ -0,0 +1,668 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelAspectRatio = exports.Framerate = exports.EncryptionKeyType = exports.VpcInterface = exports.NetworkInterface = exports.MediaLivePipeline = exports.FailoverMode = exports.GatewayNetwork = exports.BridgeProtocol = exports.MaintenanceDay = exports.State = exports.KeyType = exports.EncryptionAlgorithm = void 0;
+exports.renderTags = renderTags;
+exports.toTitleCase = toTitleCase;
+exports.validateMaintenanceTime = validateMaintenanceTime;
+exports.resolveEncryptionRole = resolveEncryptionRole;
+exports.renderStaticKeyEncryption = renderStaticKeyEncryption;
+exports.renderSrtPasswordEncryption = renderSrtPasswordEncryption;
+exports.renderRouterSrtEncryption = renderRouterSrtEncryption;
+exports.renderTransitEncryption = renderTransitEncryption;
+exports.resolveTransitEncryption = resolveTransitEncryption;
+exports.resolveRouterSrtEncryption = resolveRouterSrtEncryption;
+exports.exceedsRouterTierBitrate = exceedsRouterTierBitrate;
+exports.isOpenCidr = isOpenCidr;
+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_iam_1 = require("aws-cdk-lib/aws-iam");
+const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+/**
+ * Encryption Algorithms used in AWS Elemental MediaConnect
+ */
+class EncryptionAlgorithm {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.EncryptionAlgorithm", version: "2.263.0-alpha.0" };
+    /**
+     * Option for AES128
+     */
+    static AES128 = new EncryptionAlgorithm('aes128');
+    /**
+     * Option for AES192
+     */
+    static AES192 = new EncryptionAlgorithm('aes192');
+    /**
+     * Option for AES256
+     */
+    static AES256 = new EncryptionAlgorithm('aes256');
+    /**
+     * Use a custom encryption algorithm value
+     * @param value The encryption algorithm string value
+     */
+    static of(value) {
+        return new EncryptionAlgorithm(value);
+    }
+    /**
+     * @param value The encryption algorithm string value
+     */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.EncryptionAlgorithm = EncryptionAlgorithm;
+/**
+ * Key types used across AWS Elemental MediaConnect
+ */
+class KeyType {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.KeyType", version: "2.263.0-alpha.0" };
+    /**
+     * Option for Static Key
+     */
+    static STATIC_KEY = new KeyType('static-key');
+    /**
+     * Option for SRT Password
+     */
+    static SRT_PASSWORD = new KeyType('srt-password');
+    /**
+     * Use a custom key type value
+     * @param value The key type string value
+     */
+    static of(value) {
+        return new KeyType(value);
+    }
+    /**
+     * @param value The key type string value
+     */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.KeyType = KeyType;
+/**
+ * State configuration used across AWS Elemental MediaConnect
+ */
+var State;
+(function (State) {
+    /**
+     * Option for Enabled
+     */
+    State["ENABLED"] = "ENABLED";
+    /**
+     * Option for Disabled
+     */
+    State["DISABLED"] = "DISABLED";
+})(State || (exports.State = State = {}));
+/**
+ * Days of the week for scheduled maintenance windows.
+ *
+ * Used by both Flow and Router maintenance configurations.
+ */
+var MaintenanceDay;
+(function (MaintenanceDay) {
+    /** Monday */
+    MaintenanceDay["MONDAY"] = "MONDAY";
+    /** Tuesday */
+    MaintenanceDay["TUESDAY"] = "TUESDAY";
+    /** Wednesday */
+    MaintenanceDay["WEDNESDAY"] = "WEDNESDAY";
+    /** Thursday */
+    MaintenanceDay["THURSDAY"] = "THURSDAY";
+    /** Friday */
+    MaintenanceDay["FRIDAY"] = "FRIDAY";
+    /** Saturday */
+    MaintenanceDay["SATURDAY"] = "SATURDAY";
+    /** Sunday */
+    MaintenanceDay["SUNDAY"] = "SUNDAY";
+})(MaintenanceDay || (exports.MaintenanceDay = MaintenanceDay = {}));
+/**
+ * Options for bridge network source and output protocols.
+ */
+class BridgeProtocol {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.BridgeProtocol", version: "2.263.0-alpha.0" };
+    /**
+     * Option for RTP-FEC
+     */
+    static RTP_FEC = new BridgeProtocol('rtp-fec');
+    /**
+     * Option for RTP
+     */
+    static RTP = new BridgeProtocol('rtp');
+    /**
+     * Option for UDP
+     */
+    static UDP = new BridgeProtocol('udp');
+    /**
+     * Use a custom bridge protocol value
+     * @param value The bridge protocol string value
+     */
+    static of(value) {
+        return new BridgeProtocol(value);
+    }
+    /**
+     * @param value The bridge protocol string value
+     */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.BridgeProtocol = BridgeProtocol;
+/**
+ * A network on a MediaConnect Gateway.
+ *
+ * Use {@link GatewayNetwork.define} to create a network and reference it from
+ * gateway, bridge source, and bridge output configurations.
+ *
+ * @example
+ *
+ *    const productionNetwork = GatewayNetwork.define({
+ *      name: 'production',
+ *      cidrBlock: '10.0.0.0/16',
+ *    });
+ */
+class GatewayNetwork {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.GatewayNetwork", version: "2.263.0-alpha.0" };
+    /**
+     * Define a new gateway network.
+     *
+     * @param props network properties
+     */
+    static define(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_GatewayNetworkDefineProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.define);
+            }
+            throw error;
+        }
+        if (!aws_cdk_lib_1.Token.isUnresolved(props.name)) {
+            if (props.name.length < 1 || props.name.length > 64) {
+                throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `GatewayNetworkNameLength`, `Gateway network name must be between 1 and 64 characters, got ${props.name.length}`);
+            }
+            if (!/^[a-zA-Z0-9_-]+$/.test(props.name)) {
+                throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `GatewayNetworkNameFormat`, `Gateway network name must contain only alphanumeric characters, hyphens, and underscores, got '${props.name}'`);
+            }
+        }
+        return new GatewayNetwork(props.name, props.cidrBlock);
+    }
+    /**
+     * The name of the network.
+     */
+    name;
+    /**
+     * A unique IP address range to use for this network in CIDR notation.
+     */
+    cidrBlock;
+    constructor(name, cidrBlock) {
+        this.name = name;
+        this.cidrBlock = cidrBlock;
+    }
+}
+exports.GatewayNetwork = GatewayNetwork;
+/**
+ * Failover Mode
+ */
+class FailoverMode {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.FailoverMode", version: "2.263.0-alpha.0" };
+    /**
+     * MERGE combines the source streams into a single stream, allowing graceful
+     * recovery from any single-source loss.
+     */
+    static MERGE = new FailoverMode('MERGE');
+    /**
+     * FAILOVER allows switching between different streams.
+     */
+    static FAILOVER = new FailoverMode('FAILOVER');
+    /**
+     * Use a custom failover mode value
+     * @param value The failover mode string value
+     */
+    static of(value) {
+        return new FailoverMode(value);
+    }
+    /**
+     * @param value The failover mode string value
+     */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.FailoverMode = FailoverMode;
+/**
+ * Render tags for CloudFormation resources.
+ *
+ * @internal
+ */
+function renderTags(tags) {
+    return Object.entries(tags).map(([key, value]) => ({
+        key,
+        value,
+    }));
+}
+/**
+ * Convert an uppercase enum value to title case (e.g. 'MONDAY' → 'Monday').
+ * Used at CFN boundaries where the API expects title-cased day names.
+ *
+ * @internal
+ */
+function toTitleCase(day) {
+    return day.charAt(0) + day.slice(1).toLowerCase();
+}
+/**
+ * Validate a maintenance start hour string is in HH:00 format (24-hour, minutes must be 00).
+ * @param time The time string to validate
+ * @throws UnscopedValidationError if the format is invalid
+ *
+ * @internal
+ */
+function validateMaintenanceTime(time) {
+    if (aws_cdk_lib_1.Token.isUnresolved(time)) {
+        return;
+    }
+    if (!/^([01]\d|2[0-3]):00$/.test(time)) {
+        throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `MaintenanceTimeFormat`, `Maintenance time must be in HH:00 format (24-hour, minutes must be 00), got '${time}'`);
+    }
+}
+/**
+ * MediaLive pipeline options.
+ */
+var MediaLivePipeline;
+(function (MediaLivePipeline) {
+    /** Pipeline 0 */
+    MediaLivePipeline["PIPELINE_0"] = "PIPELINE_0";
+    /** Pipeline 1 */
+    MediaLivePipeline["PIPELINE_1"] = "PIPELINE_1";
+})(MediaLivePipeline || (exports.MediaLivePipeline = MediaLivePipeline = {}));
+/**
+ * Network interface options
+ */
+class NetworkInterface {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.NetworkInterface", version: "2.263.0-alpha.0" };
+    /**
+     * Option for ENA
+     */
+    static ENA = new NetworkInterface('ena');
+    /**
+     * Option for EFA.
+     * For CDI ensure you use EFA.
+     */
+    static EFA = new NetworkInterface('efa');
+    /**
+     * Use a custom network interface value
+     * @param value The network interface string value
+     */
+    static of(value) {
+        return new NetworkInterface(value);
+    }
+    /**
+     * @param value The network interface string value
+     */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.NetworkInterface = NetworkInterface;
+/**
+ * Factory class for creating VPC Interface configurations
+ */
+class VpcInterface {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.VpcInterface", version: "2.263.0-alpha.0" };
+    /**
+     * Define a new VPC Interface configuration. MediaConnect will create network interfaces automatically.
+     *
+     * @param props VPC Interface properties
+     * @returns VpcInterfaceConfig configuration object
+     */
+    static define(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_VpcInterfaceDefineProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.define);
+            }
+            throw error;
+        }
+        return {
+            name: props.vpcInterfaceName,
+            role: props.role,
+            securityGroups: props.securityGroups,
+            subnet: props.subnet,
+            networkInterfaceType: props.networkInterfaceType,
+        };
+    }
+    /**
+     * Create a VPC Interface configuration using existing network interfaces.
+     *
+     * @param props VPC Interface properties with existing network interface IDs
+     * @returns VpcInterfaceConfig configuration object
+     */
+    static fromNetworkInterfaces(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_VpcInterfaceFromNetworkInterfacesProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.fromNetworkInterfaces);
+            }
+            throw error;
+        }
+        return {
+            name: props.vpcInterfaceName,
+            role: props.role,
+            securityGroups: props.securityGroups,
+            subnet: props.subnet,
+            networkInterfaceIds: props.networkInterfaceIds,
+        };
+    }
+}
+exports.VpcInterface = VpcInterface;
+/**
+ * Encryption key type for transit encryption
+ * @internal
+ */
+var EncryptionKeyType;
+(function (EncryptionKeyType) {
+    EncryptionKeyType["SECRETS_MANAGER"] = "SECRETS_MANAGER";
+    EncryptionKeyType["AUTOMATIC"] = "AUTOMATIC";
+})(EncryptionKeyType || (exports.EncryptionKeyType = EncryptionKeyType = {}));
+/**
+ * Resolve an IAM role for MediaConnect to access a Secrets Manager secret. Returns the
+ * user-provided `role` if present, otherwise auto-creates a scoped role: inline secret read,
+ * `kms:Decrypt` when the secret has a CMK, and a trust policy with `aws:SourceAccount`
+ * (plus `aws:SourceArn` when `sourceArn` is given). The returned `grant` lets callers order
+ * the role's secret-read policy before the consuming resource — required for router I/O.
+ *
+ * A provided role is used as-is and is not granted secret access — the caller is
+ * responsible for ensuring it can read the secret (and decrypt its KMS key, if any).
+ *
+ * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/cross-service-confused-deputy-prevention.html
+ * @internal
+ */
+function resolveEncryptionRole(scope, id, role, secret, sourceArn) {
+    if (role)
+        return { role };
+    const conditions = {
+        StringEquals: { 'aws:SourceAccount': aws_cdk_lib_1.Aws.ACCOUNT_ID },
+    };
+    if (sourceArn !== undefined) {
+        conditions.ArnLike = { 'aws:SourceArn': sourceArn };
+    }
+    const created = new aws_iam_1.Role(scope, id, {
+        assumedBy: new aws_iam_1.ServicePrincipal('mediaconnect.amazonaws.com', { conditions }),
+        description: 'Auto-generated MediaConnect role for accessing the encryption secret',
+    });
+    // Grant helper: adds secret read (GetSecretValue/DescribeSecret) plus kms:Decrypt
+    // (with a kms:ViaService condition) when the secret uses a customer-managed key.
+    const readGrant = secret.grantRead(created);
+    // grantRead covers 2 of the 4 secret-read actions MediaConnect's policy needs; add the
+    // other 2, scoped to the same secret. (Skipping the doc's `ListSecrets` — it needs
+    // `Resource: *` and isn't required to read a known secret.)
+    // https://docs.aws.amazon.com/mediaconnect/latest/ug/iam-policy-examples-asm-secrets.html
+    const extraGrant = aws_iam_1.Grant.addToPrincipal({
+        grantee: created,
+        actions: ['secretsmanager:GetResourcePolicy', 'secretsmanager:ListSecretVersionIds'],
+        resourceArns: [secret.secretArn],
+    });
+    return { role: created, grant: readGrant.combine(extraGrant) };
+}
+/**
+ * Render the CFN static-key encryption block, auto-creating a role when none is supplied.
+ * @internal
+ */
+function renderStaticKeyEncryption(scope, encryption, sourceArn) {
+    const { role } = resolveEncryptionRole(scope, 'EncryptionRole', encryption.role, encryption.secret, sourceArn);
+    return {
+        keyType: KeyType.STATIC_KEY.value,
+        roleArn: role.roleArn,
+        secretArn: encryption.secret.secretArn,
+        algorithm: encryption.algorithm.value,
+    };
+}
+/**
+ * Render the CFN SRT-password encryption block, auto-creating a role when none is supplied.
+ * @internal
+ */
+function renderSrtPasswordEncryption(scope, encryption, sourceArn) {
+    const { role } = resolveEncryptionRole(scope, 'EncryptionRole', encryption.role, encryption.secret, sourceArn);
+    return {
+        keyType: KeyType.SRT_PASSWORD.value,
+        roleArn: role.roleArn,
+        secretArn: encryption.secret.secretArn,
+    };
+}
+/**
+ * Render the CFN router SRT encryption block (inner `encryptionKey` object),
+ * auto-creating a role when none is supplied.
+ * @internal
+ */
+function renderRouterSrtEncryption(scope, id, encryption, sourceArn) {
+    const { role } = resolveEncryptionRole(scope, id, encryption.role, encryption.secret, sourceArn);
+    return {
+        encryptionKey: {
+            roleArn: role.roleArn,
+            secretArn: encryption.secret.secretArn,
+        },
+    };
+}
+/**
+ * Render the CFN transit encryption block: SECRETS_MANAGER (auto-creating a role when
+ * none is supplied) when `encryption` is given, otherwise the AUTOMATIC default.
+ * @internal
+ */
+function renderTransitEncryption(scope, id, encryption, sourceArn) {
+    if (encryption) {
+        const { role } = resolveEncryptionRole(scope, id, encryption.role, encryption.secret, sourceArn);
+        return {
+            encryptionKeyConfiguration: {
+                secretsManager: {
+                    roleArn: role.roleArn,
+                    secretArn: encryption.secret.secretArn,
+                },
+            },
+            encryptionKeyType: EncryptionKeyType.SECRETS_MANAGER,
+        };
+    }
+    return {
+        encryptionKeyType: EncryptionKeyType.AUTOMATIC,
+        encryptionKeyConfiguration: {
+            automatic: {},
+        },
+    };
+}
+/**
+ * Resolve transit encryption to its CFN config plus the auto-created role's secret-read
+ * grant (when a role was auto-created).
+ * @internal
+ */
+function resolveTransitEncryption(scope, id, encryption, sourceArn) {
+    const resolved = encryption
+        ? resolveEncryptionRole(scope, id, encryption.role, encryption.secret, sourceArn)
+        : undefined;
+    const config = renderTransitEncryption(scope, id, encryption && resolved ? { ...encryption, role: resolved.role } : encryption, sourceArn);
+    return { config, grant: resolved?.grant };
+}
+/**
+ * Resolve router SRT encryption to its CFN config plus the auto-created role's secret-read
+ * grant (when a role was auto-created), so the consuming router I/O can order it before
+ * itself. See {@link resolveTransitEncryption} for why the ordering matters.
+ * @internal
+ */
+function resolveRouterSrtEncryption(scope, id, encryption, sourceArn) {
+    const resolved = resolveEncryptionRole(scope, id, encryption.role, encryption.secret, sourceArn);
+    const config = renderRouterSrtEncryption(scope, id, { ...encryption, role: resolved.role }, sourceArn);
+    return { config, grant: resolved.grant };
+}
+/**
+ * A video frame rate expressed as a rational number (numerator/denominator).
+ *
+ * Use the predefined constants for standard rates, or {@link Framerate.of} for a custom rate.
+ */
+class Framerate {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.Framerate", version: "2.263.0-alpha.0" };
+    /** 24 fps (cinema) — `24/1`. */
+    static FPS_24 = new Framerate(24, 1);
+    /** 25 fps — `25/1`. */
+    static FPS_25 = new Framerate(25, 1);
+    /** 29.97 fps — `30000/1001`. */
+    static FPS_29_97 = new Framerate(30000, 1001);
+    /** 30 fps — `30/1`. */
+    static FPS_30 = new Framerate(30, 1);
+    /** 50 fps — `50/1`. */
+    static FPS_50 = new Framerate(50, 1);
+    /** 59.94 fps — `60000/1001`. */
+    static FPS_59_94 = new Framerate(60000, 1001);
+    /** 60 fps — `60/1`. */
+    static FPS_60 = new Framerate(60, 1);
+    /**
+     * Define a custom frame rate.
+     *
+     * @param numerator Numerator of the rate.
+     * @param denominator Denominator of the rate.
+     */
+    static of(numerator, denominator) {
+        if (!aws_cdk_lib_1.Token.isUnresolved(numerator) && (!Number.isInteger(numerator) || numerator <= 0)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `FramerateNumerator`, `Frame rate numerator must be a positive integer, got ${numerator}`);
+        }
+        if (!aws_cdk_lib_1.Token.isUnresolved(denominator) && (!Number.isInteger(denominator) || denominator <= 0)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `FramerateDenominator`, `Frame rate denominator must be a positive integer, got ${denominator}`);
+        }
+        return new Framerate(numerator, denominator);
+    }
+    /** @internal */
+    _numeratorValue;
+    /** @internal */
+    _denominatorValue;
+    constructor(numerator, denominator) {
+        this._numeratorValue = numerator;
+        this._denominatorValue = denominator;
+    }
+    /** Returns the string value. */
+    toString() {
+        return `${this._numeratorValue}/${this._denominatorValue}`;
+    }
+    /**
+     * Returns the number value.
+     * @internal
+     */
+    _numerator() {
+        return this._numeratorValue;
+    }
+    /**
+     * Returns the number value.
+     * @internal
+     */
+    _denominator() {
+        return this._denominatorValue;
+    }
+}
+exports.Framerate = Framerate;
+/**
+ * The pixel aspect ratio (PAR) of the video.
+ *
+ * Use the predefined constants for standard ratios, or {@link PixelAspectRatio.of} for
+ * a custom ratio.
+ */
+class PixelAspectRatio {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.PixelAspectRatio", version: "2.263.0-alpha.0" };
+    /** Square pixels (`1:1`). */
+    static SQUARE = new PixelAspectRatio(1, 1);
+    /**
+     * Define a pixel aspect ratio.
+     *
+     * @param numerator Numerator of the ratio.
+     * @param denominator Denominator of the ratio.
+     */
+    static of(numerator, denominator) {
+        if (!aws_cdk_lib_1.Token.isUnresolved(numerator) && (!Number.isInteger(numerator) || numerator <= 0)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `PixelAspectRatioNumerator`, `Pixel aspect ratio numerator must be a positive integer, got ${numerator}`);
+        }
+        if (!aws_cdk_lib_1.Token.isUnresolved(denominator) && (!Number.isInteger(denominator) || denominator <= 0)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `PixelAspectRatioDenominator`, `Pixel aspect ratio denominator must be a positive integer, got ${denominator}`);
+        }
+        return new PixelAspectRatio(numerator, denominator);
+    }
+    /** @internal */
+    _numeratorValue;
+    /** @internal */
+    _denominatorValue;
+    /**
+     * @param numerator Numerator of the ratio.
+     * @param denominator Denominator of the ratio.
+     */
+    constructor(numerator, denominator) {
+        this._numeratorValue = numerator;
+        this._denominatorValue = denominator;
+    }
+    /** Returns the string value in `numerator:denominator` form. */
+    toString() {
+        return `${this._numeratorValue}:${this._denominatorValue}`;
+    }
+    /**
+     * The numerator of the ratio.
+     * @internal
+     */
+    _numerator() {
+        return this._numeratorValue;
+    }
+    /**
+     * The denominator of the ratio.
+     * @internal
+     */
+    _denominator() {
+        return this._denominatorValue;
+    }
+}
+exports.PixelAspectRatio = PixelAspectRatio;
+/**
+ * Returns `true` when the given bitrate exceeds the specified tier's Mbps limit.
+ * Used by router input/output constructs to validate bitrate fits within the chosen tier.
+ *
+ * @param tierMbps The tier's bitrate limit in Mbps, or `undefined` for custom tiers.
+ * @param maximumBitrate The configured maximum bitrate.
+ * @returns `true` if the bitrate exceeds the tier limit; `false` otherwise (including custom tiers).
+ * @internal
+ */
+function exceedsRouterTierBitrate(tierMbps, maximumBitrate) {
+    if (tierMbps === undefined || maximumBitrate.isUnresolved())
+        return false;
+    return maximumBitrate.toBps() > tierMbps * 1_000_000;
+}
+/**
+ * Returns `true` when the given CIDR literal is a fully-open range — any `/0`
+ * prefix, covering both IPv4 (`0.0.0.0/0`) and IPv6 (`::/0`). Callers are
+ * expected to pre-check for token-encoded values, since an unresolved token
+ * cannot be inspected.
+ *
+ * @internal
+ */
+function isOpenCidr(cidr) {
+    return /\/0$/.test(cidr.trim());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared.js","sourceRoot":"","sources":["shared.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Bitrate } from 'aws-cdk-lib';\nimport { Aws, Token, UnscopedValidationError } from 'aws-cdk-lib';\nimport type { ISecurityGroup, ISubnet } from 'aws-cdk-lib/aws-ec2';\nimport { Grant, Role, ServicePrincipal } from 'aws-cdk-lib/aws-iam';\nimport type { IRole } from 'aws-cdk-lib/aws-iam';\nimport type { ISecret } from 'aws-cdk-lib/aws-secretsmanager';\nimport { lit } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport type { Construct } from 'constructs';\n\n/**\n * Encryption Algorithms used in AWS Elemental MediaConnect\n */\nexport class EncryptionAlgorithm {\n  /**\n   * Option for AES128\n   */\n  public static readonly AES128 = new EncryptionAlgorithm('aes128');\n  /**\n   * Option for AES192\n   */\n  public static readonly AES192 = new EncryptionAlgorithm('aes192');\n  /**\n   * Option for AES256\n   */\n  public static readonly AES256 = new EncryptionAlgorithm('aes256');\n\n  /**\n   * Use a custom encryption algorithm value\n   * @param value The encryption algorithm string value\n   */\n  public static of(value: string): EncryptionAlgorithm {\n    return new EncryptionAlgorithm(value);\n  }\n\n  /**\n   * @param value The encryption algorithm 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 * Key types used across AWS Elemental MediaConnect\n */\nexport class KeyType {\n  /**\n   * Option for Static Key\n   */\n  public static readonly STATIC_KEY = new KeyType('static-key');\n  /**\n   * Option for SRT Password\n   */\n  public static readonly SRT_PASSWORD = new KeyType('srt-password');\n\n  /**\n   * Use a custom key type value\n   * @param value The key type string value\n   */\n  public static of(value: string): KeyType {\n    return new KeyType(value);\n  }\n\n  /**\n   * @param value The key type 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 * State configuration used across AWS Elemental MediaConnect\n */\nexport enum State {\n  /**\n   * Option for Enabled\n   */\n  ENABLED='ENABLED',\n  /**\n   * Option for Disabled\n   */\n  DISABLED='DISABLED',\n}\n\n/**\n * Days of the week for scheduled maintenance windows.\n *\n * Used by both Flow and Router maintenance configurations.\n */\nexport enum MaintenanceDay {\n  /** Monday */\n  MONDAY='MONDAY',\n  /** Tuesday */\n  TUESDAY='TUESDAY',\n  /** Wednesday */\n  WEDNESDAY='WEDNESDAY',\n  /** Thursday */\n  THURSDAY='THURSDAY',\n  /** Friday */\n  FRIDAY='FRIDAY',\n  /** Saturday */\n  SATURDAY='SATURDAY',\n  /** Sunday */\n  SUNDAY='SUNDAY',\n}\n\n/**\n * Options for bridge network source and output protocols.\n */\nexport class BridgeProtocol {\n  /**\n   * Option for RTP-FEC\n   */\n  public static readonly RTP_FEC = new BridgeProtocol('rtp-fec');\n  /**\n   * Option for RTP\n   */\n  public static readonly RTP = new BridgeProtocol('rtp');\n  /**\n   * Option for UDP\n   */\n  public static readonly UDP = new BridgeProtocol('udp');\n\n  /**\n   * Use a custom bridge protocol value\n   * @param value The bridge protocol string value\n   */\n  public static of(value: string): BridgeProtocol {\n    return new BridgeProtocol(value);\n  }\n\n  /**\n   * @param value The bridge 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 * Properties for defining a Gateway network.\n */\nexport interface GatewayNetworkDefineProps {\n  /**\n   * The name of the network. Used to reference this network from bridge sources\n   * and outputs, and must be unique among the networks on the gateway.\n   *\n   * Maximum 64 characters; alphanumeric, hyphens, and underscores only.\n   */\n  readonly name: string;\n  /**\n   * A unique IP address range to use for this network. Must be in CIDR notation\n   * (for example, `10.0.0.0/16`).\n   */\n  readonly cidrBlock: string;\n}\n\n/**\n * A network on a MediaConnect Gateway.\n *\n * Use {@link GatewayNetwork.define} to create a network and reference it from\n * gateway, bridge source, and bridge output configurations.\n *\n * @example\n *\n *    const productionNetwork = GatewayNetwork.define({\n *      name: 'production',\n *      cidrBlock: '10.0.0.0/16',\n *    });\n */\nexport class GatewayNetwork {\n  /**\n   * Define a new gateway network.\n   *\n   * @param props network properties\n   */\n  public static define(props: GatewayNetworkDefineProps): GatewayNetwork {\n    if (!Token.isUnresolved(props.name)) {\n      if (props.name.length < 1 || props.name.length > 64) {\n        throw new UnscopedValidationError(\n          lit`GatewayNetworkNameLength`,\n          `Gateway network name must be between 1 and 64 characters, got ${props.name.length}`,\n        );\n      }\n      if (!/^[a-zA-Z0-9_-]+$/.test(props.name)) {\n        throw new UnscopedValidationError(\n          lit`GatewayNetworkNameFormat`,\n          `Gateway network name must contain only alphanumeric characters, hyphens, and underscores, got '${props.name}'`,\n        );\n      }\n    }\n\n    return new GatewayNetwork(props.name, props.cidrBlock);\n  }\n\n  /**\n   * The name of the network.\n   */\n  public readonly name: string;\n\n  /**\n   * A unique IP address range to use for this network in CIDR notation.\n   */\n  public readonly cidrBlock: string;\n\n  private constructor(name: string, cidrBlock: string) {\n    this.name = name;\n    this.cidrBlock = cidrBlock;\n  }\n}\n\n/**\n * Bridge network source options\n */\nexport interface BridgeNetworkSource {\n  /**\n   * The network source multicast IP.\n   *\n   * Must be a valid Multicast IP address.\n   */\n  readonly multicastIp: string;\n  /**\n   * The setting related to the multicast source.\n   *\n   * The IP address of the source for source-specific multicast (SSM).\n   *\n   * @default - no multicast source IP\n   */\n  readonly multicastSourceIp?: string;\n  /**\n   * The gateway network this source listens on.\n   *\n   * Use {@link GatewayNetwork.define} to create the network and pass the same\n   * instance to the gateway and to each source that uses it.\n   */\n  readonly network: GatewayNetwork;\n  /**\n   * The network source port.\n   */\n  readonly port: number;\n  /**\n   * The network source protocol.\n   */\n  readonly protocol: BridgeProtocol;\n}\n\n/**\n * Failover Mode\n */\nexport class FailoverMode {\n  /**\n   * MERGE combines the source streams into a single stream, allowing graceful\n   * recovery from any single-source loss.\n   */\n  public static readonly MERGE = new FailoverMode('MERGE');\n  /**\n   * FAILOVER allows switching between different streams.\n   */\n  public static readonly FAILOVER = new FailoverMode('FAILOVER');\n\n  /**\n   * Use a custom failover mode value\n   * @param value The failover mode string value\n   */\n  public static of(value: string): FailoverMode {\n    return new FailoverMode(value);\n  }\n\n  /**\n   * @param value The failover mode 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 * Render tags for CloudFormation resources.\n *\n * @internal\n */\nexport function renderTags(tags: { [key: string]: string }): Array<{ key: string; value: string }> {\n  return Object.entries(tags).map(([key, value]) => ({\n    key,\n    value,\n  }));\n}\n\n/**\n * Convert an uppercase enum value to title case (e.g. 'MONDAY' → 'Monday').\n * Used at CFN boundaries where the API expects title-cased day names.\n *\n * @internal\n */\nexport function toTitleCase(day: MaintenanceDay): string {\n  return day.charAt(0) + day.slice(1).toLowerCase();\n}\n\n/**\n * Validate a maintenance start hour string is in HH:00 format (24-hour, minutes must be 00).\n * @param time The time string to validate\n * @throws UnscopedValidationError if the format is invalid\n *\n * @internal\n */\nexport function validateMaintenanceTime(time: string): void {\n  if (Token.isUnresolved(time)) {\n    return;\n  }\n  if (!/^([01]\\d|2[0-3]):00$/.test(time)) {\n    throw new UnscopedValidationError(\n      lit`MaintenanceTimeFormat`,\n      `Maintenance time must be in HH:00 format (24-hour, minutes must be 00), got '${time}'`,\n    );\n  }\n}\n\n/**\n * MediaLive pipeline options.\n */\nexport enum MediaLivePipeline {\n  /** Pipeline 0 */\n  PIPELINE_0 = 'PIPELINE_0',\n  /** Pipeline 1 */\n  PIPELINE_1 = 'PIPELINE_1',\n}\n\n/**\n * Network interface options\n */\nexport class NetworkInterface {\n  /**\n   * Option for ENA\n   */\n  public static readonly ENA = new NetworkInterface('ena');\n  /**\n   * Option for EFA.\n   * For CDI ensure you use EFA.\n   */\n  public static readonly EFA = new NetworkInterface('efa');\n\n  /**\n   * Use a custom network interface value\n   * @param value The network interface string value\n   */\n  public static of(value: string): NetworkInterface {\n    return new NetworkInterface(value);\n  }\n\n  /**\n   * @param value The network interface 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 * VPC Interface configuration\n */\nexport interface VpcInterfaceConfig {\n  /**\n   * Unique name for this VPC interface within the flow. Cannot be changed after creation.\n   */\n  readonly name: string;\n  /**\n   * IDs of the network interfaces. Set this when importing existing ENIs via\n   * `VpcInterface.fromNetworkInterfaces()`; leave unset to have MediaConnect create them.\n   *\n   * @default - MediaConnect creates network interfaces automatically\n   */\n  readonly networkInterfaceIds?: string[];\n  /**\n   * The type of network interface. Use `EFA` for CDI workflows.\n   *\n   * @default - undefined; when omitted, MediaConnect applies NetworkInterface.ENA at deploy time\n   */\n  readonly networkInterfaceType?: NetworkInterface;\n  /**\n   * IAM role that MediaConnect assumes to create ENIs in your account.\n   */\n  readonly role: IRole;\n  /**\n   * Security groups to apply to the ENI.\n   */\n  readonly securityGroups: ISecurityGroup[];\n  /**\n   * Subnet where the ENI is created. Must be in the same Availability Zone as the flow.\n   */\n  readonly subnet: ISubnet;\n}\n\n/**\n * Properties for defining a new VPC Interface configuration\n */\nexport interface VpcInterfaceDefineProps {\n  /**\n   * Unique name for this VPC interface within the flow. Cannot be changed after creation.\n   */\n  readonly vpcInterfaceName: string;\n  /**\n   * IAM role that MediaConnect assumes to create ENIs in your account.\n   */\n  readonly role: IRole;\n  /**\n   * Security groups to apply to the ENI.\n   */\n  readonly securityGroups: ISecurityGroup[];\n  /**\n   * Subnet where the ENI is created. Must be in the same Availability Zone as the flow.\n   */\n  readonly subnet: ISubnet;\n  /**\n   * The type of network interface. Use `EFA` for CDI workflows.\n   *\n   * @default - undefined; when omitted, MediaConnect applies NetworkInterface.ENA at deploy time\n   */\n  readonly networkInterfaceType?: NetworkInterface;\n}\n\n/**\n * Properties for creating a VPC Interface from existing network interfaces\n */\nexport interface VpcInterfaceFromNetworkInterfacesProps {\n  /**\n   * Unique name for this VPC interface within the flow. Cannot be changed after creation.\n   */\n  readonly vpcInterfaceName: string;\n  /**\n   * IAM role that MediaConnect assumes to access the ENIs.\n   */\n  readonly role: IRole;\n  /**\n   * Security groups applied to the existing ENIs.\n   */\n  readonly securityGroups: ISecurityGroup[];\n  /**\n   * Subnet where the existing ENIs live. Must be in the same Availability Zone as the flow.\n   */\n  readonly subnet: ISubnet;\n  /**\n   * IDs of the pre-created network interfaces to reuse.\n   */\n  readonly networkInterfaceIds: string[];\n}\n\n/**\n * Factory class for creating VPC Interface configurations\n */\nexport class VpcInterface {\n  /**\n   * Define a new VPC Interface configuration. MediaConnect will create network interfaces automatically.\n   *\n   * @param props VPC Interface properties\n   * @returns VpcInterfaceConfig configuration object\n   */\n  public static define(props: VpcInterfaceDefineProps): VpcInterfaceConfig {\n    return {\n      name: props.vpcInterfaceName,\n      role: props.role,\n      securityGroups: props.securityGroups,\n      subnet: props.subnet,\n      networkInterfaceType: props.networkInterfaceType,\n    };\n  }\n\n  /**\n   * Create a VPC Interface configuration using existing network interfaces.\n   *\n   * @param props VPC Interface properties with existing network interface IDs\n   * @returns VpcInterfaceConfig configuration object\n   */\n  public static fromNetworkInterfaces(props: VpcInterfaceFromNetworkInterfacesProps): VpcInterfaceConfig {\n    return {\n      name: props.vpcInterfaceName,\n      role: props.role,\n      securityGroups: props.securityGroups,\n      subnet: props.subnet,\n      networkInterfaceIds: props.networkInterfaceIds,\n    };\n  }\n}\n/**\n * Static key encryption/decryption configuration for Zixi protocol sources and outputs,\n * and flow entitlements.\n *\n * The secret must live in the same AWS account and Region as the resource (source,\n * output, or entitlement) that uses it. MediaConnect does not support cross-account or\n * cross-Region secrets.\n *\n * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/encryption-static-key-set-up.html\n * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/cross-service-confused-deputy-prevention.html\n */\nexport interface StaticKeyEncryption {\n  /**\n   * IAM role that MediaConnect assumes to access the Secrets Manager secret.\n   *\n   * If provided, the role is used as-is; you must grant it the necessary permissions\n   * yourself.\n   *\n   * @default - a scoped role is auto-created with read access to the secret (including\n   * `kms:Decrypt` for a customer-managed key) and a confused-deputy trust condition. See\n   * the **Encryption** section of the module README for the generated trust policy.\n   */\n  readonly role?: IRole;\n  /**\n   * Secrets Manager secret containing the static encryption key.\n   */\n  readonly secret: ISecret;\n  /**\n   * The encryption algorithm to use.\n   */\n  readonly algorithm: EncryptionAlgorithm;\n}\n\n/**\n * SRT password encryption/decryption configuration for SRT Listener and SRT Caller\n * sources and outputs on flows.\n *\n * The secret must live in the same AWS account and Region as the resource (source or\n * output) that uses it. MediaConnect does not support cross-account or cross-Region\n * secrets.\n *\n * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/encryption-srt-password-set-up.html\n * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/cross-service-confused-deputy-prevention.html\n */\nexport interface SrtPasswordEncryption {\n  /**\n   * IAM role that MediaConnect assumes to access the Secrets Manager secret.\n   *\n   * If provided, the role is used as-is; you must grant it the necessary permissions\n   * yourself.\n   *\n   * @default - a scoped role is auto-created with read access to the secret and a\n   * confused-deputy trust condition. See the **Encryption** section of the module README\n   * for the generated trust policy.\n   */\n  readonly role?: IRole;\n  /**\n   * Secrets Manager secret containing the SRT passphrase.\n   */\n  readonly secret: ISecret;\n}\n\n/**\n * Transit encryption configuration for router integrations — securing the link between a\n * router and a flow or a MediaLive channel/input. Uses AWS Secrets Manager for key\n * management.\n *\n * The secret must live in the same AWS account and Region as the consuming resource.\n * MediaConnect does not support cross-account or cross-Region secrets.\n *\n * **Trust-policy scope on routers.** Router I/O ids are service-generated (unknown at synth\n * time), and pinning the live ARN would create a CloudFormation dependency cycle — so the\n * auto-created role pins `aws:SourceArn` to a wildcarded ARN (`arn:...:routerInput:*` /\n * `arn:...:routerOutput:*`) plus `aws:SourceAccount`. To pin a tighter trust policy, supply\n * your own `role`.\n *\n * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/cross-service-confused-deputy-prevention.html\n */\nexport interface TransitEncryption {\n  /**\n   * IAM role that MediaConnect assumes to access the Secrets Manager secret.\n   *\n   * If provided, the role is used as-is; you must grant it the necessary permissions\n   * yourself.\n   *\n   * @default - a scoped role is auto-created with read access to the secret and a\n   * confused-deputy trust condition. See the **Encryption** section of the module README\n   * for the generated trust policy.\n   */\n  readonly role?: IRole;\n  /**\n   * Secrets Manager secret containing the transit encryption key.\n   */\n  readonly secret: ISecret;\n}\n\n/**\n * SRT encryption configuration for router inputs and outputs (SRT Listener and SRT\n * Caller). Uses AWS Secrets Manager for key management. Distinct from\n * {@link SrtPasswordEncryption}, which is used for flow sources and outputs.\n *\n * The secret must live in the same AWS account and Region as the router I/O that uses\n * it. MediaConnect does not support cross-account or cross-Region secrets.\n *\n * **Trust-policy scope on routers.** Router I/O ids are service-generated (unknown at synth\n * time), and pinning the live ARN would create a CloudFormation dependency cycle — so the\n * auto-created role pins `aws:SourceArn` to a wildcarded ARN (`arn:...:routerInput:*` /\n * `arn:...:routerOutput:*`) plus `aws:SourceAccount`. To pin a tighter trust policy, supply\n * your own `role`.\n *\n * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/cross-service-confused-deputy-prevention.html\n */\nexport interface RouterSrtEncryption {\n  /**\n   * IAM role that MediaConnect assumes to access the Secrets Manager secret.\n   *\n   * If provided, the role is used as-is; you must grant it the necessary permissions\n   * yourself.\n   *\n   * @default - a scoped role is auto-created with read access to the secret and a\n   * confused-deputy trust condition. See the **Encryption** section of the module README\n   * for the generated trust policy.\n   */\n  readonly role?: IRole;\n  /**\n   * Secrets Manager secret containing the SRT passphrase.\n   */\n  readonly secret: ISecret;\n}\n\n/**\n * Encryption key type for transit encryption\n * @internal\n */\nexport enum EncryptionKeyType {\n  SECRETS_MANAGER='SECRETS_MANAGER',\n  AUTOMATIC='AUTOMATIC',\n}\n\n/**\n * Resolve an IAM role for MediaConnect to access a Secrets Manager secret. Returns the\n * user-provided `role` if present, otherwise auto-creates a scoped role: inline secret read,\n * `kms:Decrypt` when the secret has a CMK, and a trust policy with `aws:SourceAccount`\n * (plus `aws:SourceArn` when `sourceArn` is given). The returned `grant` lets callers order\n * the role's secret-read policy before the consuming resource — required for router I/O.\n *\n * A provided role is used as-is and is not granted secret access — the caller is\n * responsible for ensuring it can read the secret (and decrypt its KMS key, if any).\n *\n * @see https://docs.aws.amazon.com/mediaconnect/latest/ug/cross-service-confused-deputy-prevention.html\n * @internal\n */\nexport function resolveEncryptionRole(\n  scope: Construct,\n  id: string,\n  role: IRole | undefined,\n  secret: ISecret,\n  sourceArn?: string,\n): { role: IRole; grant?: Grant } {\n  if (role) return { role };\n\n  const conditions: Record<string, Record<string, string>> = {\n    StringEquals: { 'aws:SourceAccount': Aws.ACCOUNT_ID },\n  };\n  if (sourceArn !== undefined) {\n    conditions.ArnLike = { 'aws:SourceArn': sourceArn };\n  }\n\n  const created = new Role(scope, id, {\n    assumedBy: new ServicePrincipal('mediaconnect.amazonaws.com', { conditions }),\n    description: 'Auto-generated MediaConnect role for accessing the encryption secret',\n  });\n\n  // Grant helper: adds secret read (GetSecretValue/DescribeSecret) plus kms:Decrypt\n  // (with a kms:ViaService condition) when the secret uses a customer-managed key.\n  const readGrant = secret.grantRead(created);\n\n  // grantRead covers 2 of the 4 secret-read actions MediaConnect's policy needs; add the\n  // other 2, scoped to the same secret. (Skipping the doc's `ListSecrets` — it needs\n  // `Resource: *` and isn't required to read a known secret.)\n  // https://docs.aws.amazon.com/mediaconnect/latest/ug/iam-policy-examples-asm-secrets.html\n  const extraGrant = Grant.addToPrincipal({\n    grantee: created,\n    actions: ['secretsmanager:GetResourcePolicy', 'secretsmanager:ListSecretVersionIds'],\n    resourceArns: [secret.secretArn],\n  });\n\n  return { role: created, grant: readGrant.combine(extraGrant) };\n}\n\n/**\n * Render the CFN static-key encryption block, auto-creating a role when none is supplied.\n * @internal\n */\nexport function renderStaticKeyEncryption(scope: Construct, encryption: StaticKeyEncryption, sourceArn?: string) {\n  const { role } = resolveEncryptionRole(scope, 'EncryptionRole', encryption.role, encryption.secret, sourceArn);\n  return {\n    keyType: KeyType.STATIC_KEY.value,\n    roleArn: role.roleArn,\n    secretArn: encryption.secret.secretArn,\n    algorithm: encryption.algorithm.value,\n  };\n}\n\n/**\n * Render the CFN SRT-password encryption block, auto-creating a role when none is supplied.\n * @internal\n */\nexport function renderSrtPasswordEncryption(scope: Construct, encryption: SrtPasswordEncryption, sourceArn?: string) {\n  const { role } = resolveEncryptionRole(scope, 'EncryptionRole', encryption.role, encryption.secret, sourceArn);\n  return {\n    keyType: KeyType.SRT_PASSWORD.value,\n    roleArn: role.roleArn,\n    secretArn: encryption.secret.secretArn,\n  };\n}\n\n/**\n * Render the CFN router SRT encryption block (inner `encryptionKey` object),\n * auto-creating a role when none is supplied.\n * @internal\n */\nexport function renderRouterSrtEncryption(scope: Construct, id: string, encryption: RouterSrtEncryption, sourceArn?: string) {\n  const { role } = resolveEncryptionRole(scope, id, encryption.role, encryption.secret, sourceArn);\n  return {\n    encryptionKey: {\n      roleArn: role.roleArn,\n      secretArn: encryption.secret.secretArn,\n    },\n  };\n}\n\n/**\n * Render the CFN transit encryption block: SECRETS_MANAGER (auto-creating a role when\n * none is supplied) when `encryption` is given, otherwise the AUTOMATIC default.\n * @internal\n */\nexport function renderTransitEncryption(scope: Construct, id: string, encryption?: TransitEncryption, sourceArn?: string) {\n  if (encryption) {\n    const { role } = resolveEncryptionRole(scope, id, encryption.role, encryption.secret, sourceArn);\n    return {\n      encryptionKeyConfiguration: {\n        secretsManager: {\n          roleArn: role.roleArn,\n          secretArn: encryption.secret.secretArn,\n        },\n      },\n      encryptionKeyType: EncryptionKeyType.SECRETS_MANAGER,\n    };\n  }\n  return {\n    encryptionKeyType: EncryptionKeyType.AUTOMATIC,\n    encryptionKeyConfiguration: {\n      automatic: {},\n    },\n  };\n}\n\n/**\n * Resolve transit encryption to its CFN config plus the auto-created role's secret-read\n * grant (when a role was auto-created).\n * @internal\n */\nexport function resolveTransitEncryption(scope: Construct, id: string, encryption?: TransitEncryption, sourceArn?: string) {\n  const resolved = encryption\n    ? resolveEncryptionRole(scope, id, encryption.role, encryption.secret, sourceArn)\n    : undefined;\n  const config = renderTransitEncryption(\n    scope,\n    id,\n    encryption && resolved ? { ...encryption, role: resolved.role } : encryption,\n    sourceArn,\n  );\n  return { config, grant: resolved?.grant };\n}\n\n/**\n * Resolve router SRT encryption to its CFN config plus the auto-created role's secret-read\n * grant (when a role was auto-created), so the consuming router I/O can order it before\n * itself. See {@link resolveTransitEncryption} for why the ordering matters.\n * @internal\n */\nexport function resolveRouterSrtEncryption(scope: Construct, id: string, encryption: RouterSrtEncryption, sourceArn?: string) {\n  const resolved = resolveEncryptionRole(scope, id, encryption.role, encryption.secret, sourceArn);\n  const config = renderRouterSrtEncryption(scope, id, { ...encryption, role: resolved.role }, sourceArn);\n  return { config, grant: resolved.grant };\n}\n\n/**\n * A video frame rate expressed as a rational number (numerator/denominator).\n *\n * Use the predefined constants for standard rates, or {@link Framerate.of} for a custom rate.\n */\nexport class Framerate {\n  /** 24 fps (cinema) — `24/1`. */\n  public static readonly FPS_24 = new Framerate(24, 1);\n  /** 25 fps — `25/1`. */\n  public static readonly FPS_25 = new Framerate(25, 1);\n  /** 29.97 fps — `30000/1001`. */\n  public static readonly FPS_29_97 = new Framerate(30000, 1001);\n  /** 30 fps — `30/1`. */\n  public static readonly FPS_30 = new Framerate(30, 1);\n  /** 50 fps — `50/1`. */\n  public static readonly FPS_50 = new Framerate(50, 1);\n  /** 59.94 fps — `60000/1001`. */\n  public static readonly FPS_59_94 = new Framerate(60000, 1001);\n  /** 60 fps — `60/1`. */\n  public static readonly FPS_60 = new Framerate(60, 1);\n\n  /**\n   * Define a custom frame rate.\n   *\n   * @param numerator Numerator of the rate.\n   * @param denominator Denominator of the rate.\n   */\n  public static of(numerator: number, denominator: number): Framerate {\n    if (!Token.isUnresolved(numerator) && (!Number.isInteger(numerator) || numerator <= 0)) {\n      throw new UnscopedValidationError(lit`FramerateNumerator`, `Frame rate numerator must be a positive integer, got ${numerator}`);\n    }\n    if (!Token.isUnresolved(denominator) && (!Number.isInteger(denominator) || denominator <= 0)) {\n      throw new UnscopedValidationError(lit`FramerateDenominator`, `Frame rate denominator must be a positive integer, got ${denominator}`);\n    }\n    return new Framerate(numerator, denominator);\n  }\n\n  /** @internal */\n  private readonly _numeratorValue: number;\n  /** @internal */\n  private readonly _denominatorValue: number;\n\n  private constructor(numerator: number, denominator: number) {\n    this._numeratorValue = numerator;\n    this._denominatorValue = denominator;\n  }\n\n  /** Returns the string value. */\n  public toString(): string {\n    return `${this._numeratorValue}/${this._denominatorValue}`;\n  }\n\n  /**\n   * Returns the number value.\n   * @internal\n   */\n  public _numerator(): number {\n    return this._numeratorValue;\n  }\n\n  /**\n   * Returns the number value.\n   * @internal\n   */\n  public _denominator(): number {\n    return this._denominatorValue;\n  }\n}\n\n/**\n * The pixel aspect ratio (PAR) of the video.\n *\n * Use the predefined constants for standard ratios, or {@link PixelAspectRatio.of} for\n * a custom ratio.\n */\nexport class PixelAspectRatio {\n  /** Square pixels (`1:1`). */\n  public static readonly SQUARE = new PixelAspectRatio(1, 1);\n\n  /**\n   * Define a pixel aspect ratio.\n   *\n   * @param numerator Numerator of the ratio.\n   * @param denominator Denominator of the ratio.\n   */\n  public static of(numerator: number, denominator: number): PixelAspectRatio {\n    if (!Token.isUnresolved(numerator) && (!Number.isInteger(numerator) || numerator <= 0)) {\n      throw new UnscopedValidationError(lit`PixelAspectRatioNumerator`, `Pixel aspect ratio numerator must be a positive integer, got ${numerator}`);\n    }\n    if (!Token.isUnresolved(denominator) && (!Number.isInteger(denominator) || denominator <= 0)) {\n      throw new UnscopedValidationError(lit`PixelAspectRatioDenominator`, `Pixel aspect ratio denominator must be a positive integer, got ${denominator}`);\n    }\n    return new PixelAspectRatio(numerator, denominator);\n  }\n\n  /** @internal */\n  private readonly _numeratorValue: number;\n  /** @internal */\n  private readonly _denominatorValue: number;\n\n  /**\n   * @param numerator Numerator of the ratio.\n   * @param denominator Denominator of the ratio.\n   */\n  private constructor(numerator: number, denominator: number) {\n    this._numeratorValue = numerator;\n    this._denominatorValue = denominator;\n  }\n\n  /** Returns the string value in `numerator:denominator` form. */\n  public toString(): string {\n    return `${this._numeratorValue}:${this._denominatorValue}`;\n  }\n\n  /**\n   * The numerator of the ratio.\n   * @internal\n   */\n  public _numerator(): number {\n    return this._numeratorValue;\n  }\n\n  /**\n   * The denominator of the ratio.\n   * @internal\n   */\n  public _denominator(): number {\n    return this._denominatorValue;\n  }\n}\n\n/**\n * Returns `true` when the given bitrate exceeds the specified tier's Mbps limit.\n * Used by router input/output constructs to validate bitrate fits within the chosen tier.\n *\n * @param tierMbps The tier's bitrate limit in Mbps, or `undefined` for custom tiers.\n * @param maximumBitrate The configured maximum bitrate.\n * @returns `true` if the bitrate exceeds the tier limit; `false` otherwise (including custom tiers).\n * @internal\n */\nexport function exceedsRouterTierBitrate(tierMbps: number | undefined, maximumBitrate: Bitrate): boolean {\n  if (tierMbps === undefined || maximumBitrate.isUnresolved()) return false;\n  return maximumBitrate.toBps() > tierMbps * 1_000_000;\n}\n\n/**\n * Returns `true` when the given CIDR literal is a fully-open range — any `/0`\n * prefix, covering both IPv4 (`0.0.0.0/0`) and IPv6 (`::/0`). Callers are\n * expected to pre-check for token-encoded values, since an unresolved token\n * cannot be inspected.\n *\n * @internal\n */\nexport function isOpenCidr(cidr: string): boolean {\n  return /\\/0$/.test(cidr.trim());\n}\n"]}