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

package/lib/bridge.js

@@ -0,0 +1,490 @@
+"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.Bridge = exports.BridgeConfiguration = exports.BridgeFailoverConfig = exports.BridgeOutputConfiguration = exports.BridgeType = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
+const aws_mediaconnect_1 = require("aws-cdk-lib/aws-mediaconnect");
+const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+const prop_injectable_1 = require("aws-cdk-lib/core/lib/prop-injectable");
+const bridge_output_1 = require("./bridge-output");
+const shared_1 = require("./shared");
+/**
+ * Configuration of bridge type
+ */
+class BridgeType {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.BridgeType", version: "2.263.0-alpha.0" };
+    /**
+     * Ingress Bridge
+     */
+    static INGRESS_BRIDGE = new BridgeType('ingress_bridge');
+    /**
+     * Egress Bridge
+     */
+    static EGRESS_BRIDGE = new BridgeType('egress_bridge');
+    /**
+     * Use a custom bridge type value
+     * @param value The bridge type string value
+     */
+    static of(value) {
+        return new BridgeType(value);
+    }
+    /** @param value The bridge type string value */
+    constructor(value) {
+        this.value = value;
+    }
+    /** Returns the string value */
+    toString() {
+        return this.value;
+    }
+}
+exports.BridgeType = BridgeType;
+/**
+ * Configuration for a bridge output.
+ */
+class BridgeOutputConfiguration {
+    _network;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.BridgeOutputConfiguration", version: "2.263.0-alpha.0" };
+    /**
+     * Create a network output configuration for a bridge.
+     */
+    static network(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_BridgeNetworkOutputProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.network);
+            }
+            throw error;
+        }
+        if (!aws_cdk_lib_1.Token.isUnresolved(props.ttl) && (props.ttl < 1 || props.ttl > 255)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `BridgeOutputTtlRange`, `TTL must be between 1 and 255 hops, got ${props.ttl}`);
+        }
+        return new BridgeOutputConfiguration(props);
+    }
+    constructor(_network) {
+        this._network = _network;
+    }
+    /**
+     * @internal
+     */
+    _bind() {
+        return {
+            ipAddress: this._network.ipAddress,
+            networkName: this._network.network.name,
+            port: this._network.port,
+            protocol: this._network.protocol.value,
+            ttl: this._network.ttl,
+        };
+    }
+}
+exports.BridgeOutputConfiguration = BridgeOutputConfiguration;
+/**
+ * Source failover configuration for a bridge.
+ *
+ * Bridges only support `FAILOVER` (switchover) mode — the `MERGE` mode available on
+ * `Flow.sourceFailoverConfig` is not allowed on bridges by the service. Use
+ * {@link BridgeFailoverConfig.failover} to construct the configuration.
+ */
+class BridgeFailoverConfig {
+    _state;
+    _primarySource;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.BridgeFailoverConfig", version: "2.263.0-alpha.0" };
+    /**
+     * Configure switchover-mode failover. The bridge swaps to the backup source when
+     * the primary source stops receiving data.
+     */
+    static failover(options = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_BridgeFailoverOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.failover);
+            }
+            throw error;
+        }
+        return new BridgeFailoverConfig(options.state ?? shared_1.State.ENABLED, options.primarySource);
+    }
+    constructor(_state, _primarySource) {
+        this._state = _state;
+        this._primarySource = _primarySource;
+    }
+    /**
+     * Whether this configuration has failover enabled.
+     * @internal
+     */
+    get _isEnabled() {
+        return this._state === shared_1.State.ENABLED;
+    }
+    /**
+     * Called when the configuration is bound to a Bridge.
+     * @internal
+     */
+    _bind() {
+        return {
+            failoverMode: shared_1.FailoverMode.FAILOVER.value,
+            state: this._state,
+            sourcePriority: this._primarySource ? { primarySource: this._primarySource } : undefined,
+        };
+    }
+}
+exports.BridgeFailoverConfig = BridgeFailoverConfig;
+/**
+ * Bridge configuration to set ingress and egress options on the bridge
+ */
+class BridgeConfiguration {
+    _bridgeType;
+    _ingressConfig;
+    _egressConfig;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediaconnect-alpha.BridgeConfiguration", version: "2.263.0-alpha.0" };
+    /**
+     * An ingress bridge is a ground-to-cloud bridge. The content originates at your premises and is delivered to the cloud.
+     */
+    static ingress(config) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_IngressBridgeConfiguration(config);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.ingress);
+            }
+            throw error;
+        }
+        if (!config.maxBitrate.isUnresolved()) {
+            const bitrateBps = config.maxBitrate.toBps();
+            if (bitrateBps < 1000000 || bitrateBps > 100000000) {
+                throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `BridgeIngressBitrateRange`, `Bridge ingress max bitrate must be between 1,000,000 and 100,000,000 bps, got ${bitrateBps}`);
+            }
+        }
+        if (!aws_cdk_lib_1.Token.isUnresolved(config.networkSources) && config.networkSources.length > 2) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `BridgeMaxNetworkSources`, `A bridge supports a maximum of 2 network sources, got ${config.networkSources.length}`);
+        }
+        return new BridgeConfiguration(BridgeType.INGRESS_BRIDGE, config, undefined);
+    }
+    /**
+     * An egress bridge is a cloud-to-ground bridge. The content comes from an existing MediaConnect flow and is delivered to your premises.
+     */
+    static egress(config) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_EgressBridgeConfiguration(config);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.egress);
+            }
+            throw error;
+        }
+        if (!config.maxBitrate.isUnresolved()) {
+            const bitrateBps = config.maxBitrate.toBps();
+            if (bitrateBps < 1000000 || bitrateBps > 100000000) {
+                throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `BridgeEgressBitrateRange`, `Bridge egress max bitrate must be between 1,000,000 and 100,000,000 bps, got ${bitrateBps}`);
+            }
+        }
+        if (!aws_cdk_lib_1.Token.isUnresolved(config.flowSources) && config.flowSources.length > 2) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `BridgeMaxFlowSources`, `A bridge supports a maximum of 2 flow sources, got ${config.flowSources.length}`);
+        }
+        if (!aws_cdk_lib_1.Token.isUnresolved(config.networkOutputs) && config.networkOutputs.length > 2) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `BridgeMaxNetworkOutputs`, `A bridge supports a maximum of 2 network outputs, got ${config.networkOutputs.length}`);
+        }
+        return new BridgeConfiguration(BridgeType.EGRESS_BRIDGE, undefined, config);
+    }
+    constructor(_bridgeType, _ingressConfig, _egressConfig) {
+        this._bridgeType = _bridgeType;
+        this._ingressConfig = _ingressConfig;
+        this._egressConfig = _egressConfig;
+    }
+    /**
+     * Called when the bridge configuration is bound to a Bridge.
+     * @internal
+     */
+    _bind() {
+        return {
+            bridgeType: this._bridgeType,
+            ingressConfig: this._ingressConfig,
+            egressConfig: this._egressConfig,
+        };
+    }
+}
+exports.BridgeConfiguration = BridgeConfiguration;
+class BridgeBase extends aws_cdk_lib_1.Resource {
+    /**
+     * Creates a Bridge construct that represents an external (imported) Bridge.
+     */
+    static fromBridgeAttributes(scope, id, attrs) {
+        class Import extends BridgeBase {
+            bridgeArn = attrs.bridgeArn;
+            bridgeState = undefined;
+            get bridgeName() {
+                if (attrs.bridgeName)
+                    return attrs.bridgeName;
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `BridgeNameNotProvided`, `'bridgeName' was not provided when importing Bridge ${this.node.path}; provide it in fromBridgeAttributes()`, this);
+            }
+            get bridgeType() {
+                if (attrs.bridgeType)
+                    return attrs.bridgeType;
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `BridgeTypeNotProvided`, `'bridgeType' was not provided when importing Bridge ${this.node.path}; provide it in fromBridgeAttributes()`, this);
+            }
+            // Imported bridges default to `false`. Pass `isFailoverEnabled: true` in the
+            // attributes when the real service-side bridge has failover enabled and you
+            // need to add a BridgeSource.
+            isFailoverEnabled = attrs.isFailoverEnabled ?? false;
+        }
+        return new Import(scope, id);
+    }
+    /**
+     * Import an existing Bridge from its ARN.
+     *
+     * Use `fromBridgeAttributes()` instead if you need access to `bridgeName`, `bridgeType`
+     * (required for `addOutput()`), or `isFailoverEnabled`.
+     */
+    static fromBridgeArn(scope, id, bridgeArn) {
+        return Bridge.fromBridgeAttributes(scope, id, { bridgeArn });
+    }
+    /** A reference to this Bridge resource. */
+    get bridgeRef() {
+        return { bridgeArn: this.bridgeArn };
+    }
+    /**
+     * Create a CloudWatch metric for this bridge.
+     */
+    metric(metricName, props) {
+        return new aws_cloudwatch_1.Metric({
+            metricName,
+            namespace: 'AWS/MediaConnect',
+            ...props,
+            dimensionsMap: {
+                BridgeARN: this.bridgeArn,
+                ...props?.dimensionsMap,
+            },
+        }).attachTo(this);
+    }
+    /**
+     * Metric for the bitrate of a specific bridge source.
+     */
+    metricSourceBitrate(bridgeSourceName, props) {
+        const metricName = this.bridgeType.value === BridgeType.EGRESS_BRIDGE.value
+            ? 'EgressBridgeSourceBitRate'
+            : 'IngressBridgeSourceBitRate';
+        return new aws_cloudwatch_1.Metric({
+            metricName,
+            namespace: 'AWS/MediaConnect',
+            statistic: 'avg',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.BITS_PER_SECOND,
+            ...props,
+            dimensionsMap: {
+                BridgeARN: this.bridgeArn,
+                BridgeSourceName: bridgeSourceName,
+                ...props?.dimensionsMap,
+            },
+        }).attachTo(this);
+    }
+    /**
+     * Metric for the percentage of packets lost on a specific bridge source.
+     */
+    metricSourcePacketLossPercent(bridgeSourceName, props) {
+        const metricName = this.bridgeType.value === BridgeType.EGRESS_BRIDGE.value
+            ? 'EgressBridgeSourcePacketLossPercent'
+            : 'IngressBridgeSourcePacketLossPercent';
+        return new aws_cloudwatch_1.Metric({
+            metricName,
+            namespace: 'AWS/MediaConnect',
+            statistic: 'avg',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.PERCENT,
+            ...props,
+            dimensionsMap: {
+                BridgeARN: this.bridgeArn,
+                BridgeSourceName: bridgeSourceName,
+                ...props?.dimensionsMap,
+            },
+        }).attachTo(this);
+    }
+    /**
+     * Metric for the total number of times the bridge switches between sources
+     * when using the `FAILOVER` failover mode.
+     */
+    metricFailoverSwitches(props) {
+        const metricName = this.bridgeType.value === BridgeType.EGRESS_BRIDGE.value
+            ? 'EgressBridgeFailoverSwitches'
+            : 'IngressBridgeFailoverSwitches';
+        return this.metric(metricName, {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            ...props,
+        });
+    }
+    /**
+     * Add a network output to this bridge (for egress bridges only).
+     *
+     * @param id Construct id for the new BridgeOutput
+     * @param networkOutput The named output to add. The `name` is the output's identity on the bridge and must be unique among outputs.
+     */
+    addOutput(id, networkOutput) {
+        if (this.bridgeType.value !== BridgeType.EGRESS_BRIDGE.value) {
+            throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `BridgeEgressOnly`, `addOutput can only be called on egress bridges, got '${this.bridgeType.value}'`, this);
+        }
+        return new bridge_output_1.BridgeOutput(this, id, {
+            bridgeOutputName: networkOutput.name,
+            bridge: this,
+            output: networkOutput.output,
+        });
+    }
+}
+/**
+ * Defines a AWS Elemental MediaConnect Bridge
+ */
+let Bridge = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = BridgeBase;
+    var Bridge = 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);
+            Bridge = _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.Bridge", version: "2.263.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-mediaconnect-alpha.Bridge';
+        bridgeArn;
+        bridgeName;
+        bridgeType;
+        bridgeState;
+        isFailoverEnabled = false;
+        constructor(scope, id, props) {
+            super(scope, id, {
+                physicalName: props?.bridgeName ?? aws_cdk_lib_1.Lazy.string({ produce: () => aws_cdk_lib_1.Names.uniqueResourceName(this, { maxLength: 64 }) }),
+            });
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_mediaconnect_alpha_BridgeProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, Bridge);
+                }
+                throw error;
+            }
+            // Validate bridge name if provided
+            if (props.bridgeName != null && props.bridgeName !== '' && !aws_cdk_lib_1.Token.isUnresolved(props.bridgeName)) {
+                if (props.bridgeName.length > 64) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `BridgeNameLength`, `Bridge name must be between 1 and 64 characters, got ${props.bridgeName.length}`, this);
+                }
+                if (!/^[a-zA-Z0-9-]+$/.test(props.bridgeName)) {
+                    throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `BridgeNameFormat`, `Bridge name must contain only alphanumeric characters and hyphens, got '${props.bridgeName}'`, this);
+                }
+            }
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            this.isFailoverEnabled = props.sourceFailoverConfig?._isEnabled ?? false;
+            const config = props.config;
+            const configBind = config._bind();
+            const ingress = configBind.ingressConfig ? {
+                ingressGatewayBridge: {
+                    maxBitrate: configBind.ingressConfig.maxBitrate.toBps(),
+                    maxOutputs: configBind.ingressConfig.maxOutputs,
+                },
+                sources: configBind.ingressConfig.networkSources.map(input => {
+                    return {
+                        networkSource: {
+                            name: input.name,
+                            multicastIp: input.source.multicastIp,
+                            networkName: input.source.network.name,
+                            port: input.source.port,
+                            protocol: input.source.protocol.value,
+                            multicastSourceSettings: {
+                                multicastSourceIp: input.source.multicastSourceIp,
+                            },
+                        },
+                    };
+                }),
+            } : undefined;
+            const egress = configBind.egressConfig ? {
+                egressGatewayBridge: {
+                    maxBitrate: configBind.egressConfig.maxBitrate.toBps(),
+                },
+                sources: configBind.egressConfig.flowSources.map(input => this.formatBridgeFlowSource(input)),
+                outputs: configBind.egressConfig.networkOutputs.map(no => ({
+                    networkOutput: { name: no.name, ...no.output._bind() },
+                })),
+            } : undefined;
+            const bridge = new aws_mediaconnect_1.CfnBridge(this, 'Resource', {
+                name: this.physicalName,
+                placementArn: props.gateway.gatewayArn,
+                ingressGatewayBridge: ingress?.ingressGatewayBridge,
+                egressGatewayBridge: egress?.egressGatewayBridge,
+                sources: ingress?.sources ?? egress?.sources ?? [],
+                outputs: egress?.outputs,
+                sourceFailoverConfig: props.sourceFailoverConfig?._bind(),
+            });
+            this.bridgeArn = bridge.attrBridgeArn;
+            this.bridgeName = this.physicalName;
+            this.bridgeState = bridge.attrBridgeState;
+            this.bridgeType = configBind.bridgeType;
+        }
+        /**
+         * Format bridge flow source into BridgeSourceProperty format
+         */
+        formatBridgeFlowSource(input) {
+            return {
+                flowSource: {
+                    flowArn: input.source.flow.flowArn,
+                    name: input.name,
+                    flowVpcInterfaceAttachment: input.source.vpcInterface ? {
+                        vpcInterfaceName: input.source.vpcInterface.name,
+                    } : undefined,
+                },
+            };
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return Bridge = _classThis;
+})();
+exports.Bridge = Bridge;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bridge.js","sourceRoot":"","sources":["bridge.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Bitrate, IResource } from 'aws-cdk-lib';\nimport { Duration, Resource, Lazy, Names, Token, ValidationError, UnscopedValidationError } from 'aws-cdk-lib';\nimport type { MetricOptions } from 'aws-cdk-lib/aws-cloudwatch';\nimport { Metric, Unit } from 'aws-cdk-lib/aws-cloudwatch';\nimport { CfnBridge } from 'aws-cdk-lib/aws-mediaconnect';\nimport type { IBridgeRef, BridgeReference } 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 { IBridgeOutput } from './bridge-output';\nimport { BridgeOutput } from './bridge-output';\nimport type { IFlow } from './flow';\nimport type { IGateway } from './gateway';\nimport type { BridgeProtocol, BridgeNetworkSource, GatewayNetwork, VpcInterfaceConfig } from './shared';\nimport { FailoverMode, State } from './shared';\n\n/**\n * The source of the bridge. A flow source originates in MediaConnect as an existing cloud flow.\n */\nexport interface BridgeFlowSource {\n  /**\n   * The cloud flow used as a source of this bridge.\n   */\n  readonly flow: IFlow;\n  /**\n   * The VPC interface attachment to use for this source.\n   *\n   * @default - no VPC interface\n   */\n  readonly vpcInterface?: VpcInterfaceConfig;\n}\n\n/**\n * A named flow source for an egress bridge.\n */\nexport interface BridgeFlowInput {\n  /**\n   * The name of the flow source. Must be unique among sources on the bridge.\n   */\n  readonly name: string;\n\n  /**\n   * The flow source configuration describing where the bridge consumes content from.\n   */\n  readonly source: BridgeFlowSource;\n}\n\n/**\n * A named network source for an ingress bridge.\n */\nexport interface BridgeNetworkInput {\n  /**\n   * The name of the network source. Must be unique among sources on the bridge.\n   */\n  readonly name: string;\n\n  /**\n   * The network source configuration describing the multicast endpoint the bridge listens to.\n   */\n  readonly source: BridgeNetworkSource;\n}\n\n/**\n * Configuration of bridge type\n */\nexport class BridgeType {\n  /**\n   * Ingress Bridge\n   */\n  public static readonly INGRESS_BRIDGE = new BridgeType('ingress_bridge');\n  /**\n   * Egress Bridge\n   */\n  public static readonly EGRESS_BRIDGE = new BridgeType('egress_bridge');\n\n  /**\n   * Use a custom bridge type value\n   * @param value The bridge type string value\n   */\n  public static of(value: string): BridgeType {\n    return new BridgeType(value);\n  }\n\n  /** @param value The bridge type string value */\n  private constructor(public readonly value: string) {}\n\n  /** Returns the string value */\n  public toString(): string {\n    return this.value;\n  }\n}\n\n/**\n * Base bridge configuration properties\n */\ninterface BridgeConfigurationBase {\n  /**\n   * The maximum expected bitrate (in bps) of the bridge.\n   */\n  readonly maxBitrate: Bitrate;\n}\n\n/**\n * Ingress bridge configuration\n */\nexport interface IngressBridgeConfiguration extends BridgeConfigurationBase {\n  /**\n   * The maximum number of outputs on the ingress bridge.\n   */\n  readonly maxOutputs: number;\n  /**\n   * The network sources for the ingress bridge.\n   */\n  readonly networkSources: BridgeNetworkInput[];\n}\n\n/**\n * Egress bridge configuration\n */\nexport interface EgressBridgeConfiguration extends BridgeConfigurationBase {\n  /**\n   * The flow sources for the egress bridge.\n   */\n  readonly flowSources: BridgeFlowInput[];\n  /**\n   * The network outputs for the egress bridge.\n   */\n  readonly networkOutputs: BridgeNetworkOutput[];\n}\n\n/**\n * Interface for Bridge\n */\nexport interface IBridge extends IResource, IBridgeRef {\n\n  /**\n   * The Amazon Resource Name (ARN) of the bridge.\n   *\n   * @attribute\n   */\n  readonly bridgeArn: string;\n\n  /**\n   * The name of the bridge.\n   *\n   * @attribute\n   */\n  readonly bridgeName: string;\n\n  /**\n   * The type of bridge (ingress or egress).\n   *\n   * @attribute\n   */\n  readonly bridgeType: BridgeType;\n\n  /**\n   * The current state of the bridge.\n   *\n   * @attribute\n   */\n  readonly bridgeState?: string;\n\n  /**\n   * Failover Configuration for Bridge\n   */\n  readonly isFailoverEnabled?: boolean;\n\n  /**\n   * Add a network output to this bridge (for egress bridges only).\n   *\n   * @param id Construct id for the new BridgeOutput\n   * @param networkOutput The named output to add. The `name` is the output's identity on the bridge and must be unique among outputs.\n   */\n  addOutput(id: string, networkOutput: BridgeNetworkOutput): IBridgeOutput;\n\n  /**\n   * Create a CloudWatch metric for this bridge.\n   *\n   * Bridge metrics are dimensioned by `BridgeARN`. See the MediaConnect\n   * documentation for available metric names (e.g. `IngressBridgeBitRate`,\n   * `EgressBridgeBitRate`, `IngressBridgePacketLossPercent`).\n   */\n  metric(metricName: string, props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the bitrate of a specific bridge source.\n   *\n   * Uses `IngressBridgeSourceBitRate` for ingress bridges and\n   * `EgressBridgeSourceBitRate` for egress bridges.\n   *\n   * @param bridgeSourceName The name of the bridge source\n   * @default - average over 60 seconds\n   */\n  metricSourceBitrate(bridgeSourceName: string, props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the percentage of packets lost on a specific bridge source.\n   *\n   * Uses `IngressBridgeSourcePacketLossPercent` for ingress bridges and\n   * `EgressBridgeSourcePacketLossPercent` for egress bridges.\n   *\n   * @param bridgeSourceName The name of the bridge source\n   * @default - average over 60 seconds\n   */\n  metricSourcePacketLossPercent(bridgeSourceName: string, props?: MetricOptions): Metric;\n\n  /**\n   * Metric for the total number of times the bridge switches between sources\n   * when using the `FAILOVER` failover mode.\n   *\n   * Uses `IngressBridgeFailoverSwitches` for ingress bridges and\n   * `EgressBridgeFailoverSwitches` for egress bridges.\n   *\n   * @default - sum over 60 seconds\n   */\n  metricFailoverSwitches(props?: MetricOptions): Metric;\n}\n\n/**\n * Properties for a bridge network output.\n */\nexport interface BridgeNetworkOutputProps {\n  /**\n   * The IP address where the output will send content.\n   */\n  readonly ipAddress: string;\n  /**\n   * The port to use for the output.\n   */\n  readonly port: number;\n  /**\n   * The gateway network this output sends content out of.\n   *\n   * Use {@link GatewayNetwork.define} to create the network and pass the same\n   * instance to the gateway and to each output that uses it.\n   */\n  readonly network: GatewayNetwork;\n  /**\n   * The protocol to use for the output.\n   */\n  readonly protocol: BridgeProtocol;\n  /**\n   * Time to live (TTL) for the output packets in hops (1-255).\n   *\n   * TTL represents the maximum number of network hops a packet can traverse\n   * before being discarded.\n   */\n  readonly ttl: number;\n}\n\n/**\n * A named network output for an egress bridge.\n */\nexport interface BridgeNetworkOutput {\n  /**\n   * The name of the network output. Must be unique among outputs on the bridge.\n   *\n   * Used as the physical name of the underlying CFN resource.\n   */\n  readonly name: string;\n\n  /**\n   * The network configuration describing where this output sends content.\n   */\n  readonly output: BridgeOutputConfiguration;\n}\n\n/**\n * Configuration for a bridge output.\n */\nexport class BridgeOutputConfiguration {\n  /**\n   * Create a network output configuration for a bridge.\n   */\n  public static network(props: BridgeNetworkOutputProps): BridgeOutputConfiguration {\n    if (!Token.isUnresolved(props.ttl) && (props.ttl < 1 || props.ttl > 255)) {\n      throw new UnscopedValidationError(lit`BridgeOutputTtlRange`, `TTL must be between 1 and 255 hops, got ${props.ttl}`);\n    }\n    return new BridgeOutputConfiguration(props);\n  }\n\n  private constructor(private readonly _network: BridgeNetworkOutputProps) {}\n\n  /**\n   * @internal\n   */\n  public _bind(): { ipAddress: string; networkName: string; port: number; protocol: string; ttl: number } {\n    return {\n      ipAddress: this._network.ipAddress,\n      networkName: this._network.network.name,\n      port: this._network.port,\n      protocol: this._network.protocol.value,\n      ttl: this._network.ttl,\n    };\n  }\n}\n\n/**\n * Options for bridge source failover.\n */\nexport interface BridgeFailoverOptions {\n  /**\n   * Whether failover is enabled. Set to `State.DISABLED` to keep the configuration\n   * on the bridge without switching failover on.\n   *\n   * @default State.ENABLED\n   */\n  readonly state?: State;\n  /**\n   * The name of the source you want to treat as primary. If set, MediaConnect always\n   * uses this source when it is available. When unset, both sources are treated with\n   * equal priority.\n   *\n   * @default - both sources are equal priority\n   */\n  readonly primarySource?: string;\n}\n\n/**\n * Source failover configuration for a bridge.\n *\n * Bridges only support `FAILOVER` (switchover) mode — the `MERGE` mode available on\n * `Flow.sourceFailoverConfig` is not allowed on bridges by the service. Use\n * {@link BridgeFailoverConfig.failover} to construct the configuration.\n */\nexport class BridgeFailoverConfig {\n  /**\n   * Configure switchover-mode failover. The bridge swaps to the backup source when\n   * the primary source stops receiving data.\n   */\n  public static failover(options: BridgeFailoverOptions = {}): BridgeFailoverConfig {\n    return new BridgeFailoverConfig(options.state ?? State.ENABLED, options.primarySource);\n  }\n\n  private constructor(\n    private readonly _state: State,\n    private readonly _primarySource: string | undefined,\n  ) {}\n\n  /**\n   * Whether this configuration has failover enabled.\n   * @internal\n   */\n  public get _isEnabled(): boolean {\n    return this._state === State.ENABLED;\n  }\n\n  /**\n   * Called when the configuration is bound to a Bridge.\n   * @internal\n   */\n  public _bind(): CfnBridge.FailoverConfigProperty {\n    return {\n      failoverMode: FailoverMode.FAILOVER.value,\n      state: this._state,\n      sourcePriority: this._primarySource ? { primarySource: this._primarySource } : undefined,\n    };\n  }\n}\n\n/**\n * Bridge configuration to set ingress and egress options on the bridge\n */\nexport class BridgeConfiguration {\n  /**\n   * An ingress bridge is a ground-to-cloud bridge. The content originates at your premises and is delivered to the cloud.\n   */\n  public static ingress(config: IngressBridgeConfiguration): BridgeConfiguration {\n    if (!config.maxBitrate.isUnresolved()) {\n      const bitrateBps = config.maxBitrate.toBps();\n      if (bitrateBps < 1000000 || bitrateBps > 100000000) {\n        throw new UnscopedValidationError(lit`BridgeIngressBitrateRange`, `Bridge ingress max bitrate must be between 1,000,000 and 100,000,000 bps, got ${bitrateBps}`);\n      }\n    }\n\n    if (!Token.isUnresolved(config.networkSources) && config.networkSources.length > 2) {\n      throw new UnscopedValidationError(\n        lit`BridgeMaxNetworkSources`,\n        `A bridge supports a maximum of 2 network sources, got ${config.networkSources.length}`,\n      );\n    }\n\n    return new BridgeConfiguration(BridgeType.INGRESS_BRIDGE, config, undefined);\n  }\n\n  /**\n   * An egress bridge is a cloud-to-ground bridge. The content comes from an existing MediaConnect flow and is delivered to your premises.\n   */\n  public static egress(config: EgressBridgeConfiguration): BridgeConfiguration {\n    if (!config.maxBitrate.isUnresolved()) {\n      const bitrateBps = config.maxBitrate.toBps();\n      if (bitrateBps < 1000000 || bitrateBps > 100000000) {\n        throw new UnscopedValidationError(lit`BridgeEgressBitrateRange`, `Bridge egress max bitrate must be between 1,000,000 and 100,000,000 bps, got ${bitrateBps}`);\n      }\n    }\n\n    if (!Token.isUnresolved(config.flowSources) && config.flowSources.length > 2) {\n      throw new UnscopedValidationError(\n        lit`BridgeMaxFlowSources`,\n        `A bridge supports a maximum of 2 flow sources, got ${config.flowSources.length}`,\n      );\n    }\n\n    if (!Token.isUnresolved(config.networkOutputs) && config.networkOutputs.length > 2) {\n      throw new UnscopedValidationError(\n        lit`BridgeMaxNetworkOutputs`,\n        `A bridge supports a maximum of 2 network outputs, got ${config.networkOutputs.length}`,\n      );\n    }\n\n    return new BridgeConfiguration(BridgeType.EGRESS_BRIDGE, undefined, config);\n  }\n\n  private constructor(\n    private readonly _bridgeType: BridgeType,\n    private readonly _ingressConfig?: IngressBridgeConfiguration,\n    private readonly _egressConfig?: EgressBridgeConfiguration,\n  ) {}\n\n  /**\n   * Called when the bridge configuration is bound to a Bridge.\n   * @internal\n   */\n  public _bind(): { bridgeType: BridgeType; ingressConfig?: IngressBridgeConfiguration; egressConfig?: EgressBridgeConfiguration } {\n    return {\n      bridgeType: this._bridgeType,\n      ingressConfig: this._ingressConfig,\n      egressConfig: this._egressConfig,\n    };\n  }\n}\n\n/**\n * Properties for the Bridge\n */\nexport interface BridgeProps {\n  /**\n   * The name of the bridge. Cannot be modified after the bridge is created.\n   *\n   * @default - autogenerated\n   */\n  readonly bridgeName?: string;\n  /**\n   * The bridge configuration specifying ingress or egress settings.\n   */\n  readonly config: BridgeConfiguration;\n  /**\n   * The gateway that the bridge is associated with.\n   */\n  readonly gateway: IGateway;\n  /**\n   * The source failover configuration for the bridge.\n   *\n   * @default - No failover configuration\n   */\n  readonly sourceFailoverConfig?: BridgeFailoverConfig;\n\n}\n\n/**\n * Attributes for importing an existing Bridge.\n */\nexport interface BridgeAttributes {\n  /**\n   * The ARN of the bridge.\n   */\n  readonly bridgeArn: string;\n\n  /**\n   * The name of the bridge.\n   *\n   * Not encoded in the bridge ARN, so must be provided explicitly if the imported\n   * bridge needs to expose `bridgeName`.\n   *\n   * @default - bridgeName is not available on the imported construct\n   */\n  readonly bridgeName?: string;\n\n  /**\n   * Indicates what type of bridge is imported.\n   *\n   * Not encoded in the bridge ARN, so must be provided explicitly if the imported\n   * bridge is used with `addOutput()` or other methods that need the bridge type.\n   *\n   * @default - bridgeType is not available on the imported construct\n   */\n  readonly bridgeType?: BridgeType;\n\n  /**\n   * Failover Configuration for Bridge\n   *\n   * @default false\n   */\n  readonly isFailoverEnabled?: boolean;\n}\n\nabstract class BridgeBase extends Resource implements IBridge {\n  /**\n   * Creates a Bridge construct that represents an external (imported) Bridge.\n   */\n  public static fromBridgeAttributes(scope: Construct, id: string, attrs: BridgeAttributes): IBridge {\n    class Import extends BridgeBase implements IBridge {\n      public readonly bridgeArn = attrs.bridgeArn;\n      public readonly bridgeState = undefined;\n\n      public get bridgeName(): string {\n        if (attrs.bridgeName) return attrs.bridgeName;\n        throw new ValidationError(\n          lit`BridgeNameNotProvided`,\n          `'bridgeName' was not provided when importing Bridge ${this.node.path}; provide it in fromBridgeAttributes()`,\n          this,\n        );\n      }\n\n      public get bridgeType(): BridgeType {\n        if (attrs.bridgeType) return attrs.bridgeType;\n        throw new ValidationError(\n          lit`BridgeTypeNotProvided`,\n          `'bridgeType' was not provided when importing Bridge ${this.node.path}; provide it in fromBridgeAttributes()`,\n          this,\n        );\n      }\n\n      // Imported bridges default to `false`. Pass `isFailoverEnabled: true` in the\n      // attributes when the real service-side bridge has failover enabled and you\n      // need to add a BridgeSource.\n      public isFailoverEnabled?: boolean = attrs.isFailoverEnabled ?? false;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Import an existing Bridge from its ARN.\n   *\n   * Use `fromBridgeAttributes()` instead if you need access to `bridgeName`, `bridgeType`\n   * (required for `addOutput()`), or `isFailoverEnabled`.\n   */\n  public static fromBridgeArn(scope: Construct, id: string, bridgeArn: string): IBridge {\n    return Bridge.fromBridgeAttributes(scope, id, { bridgeArn });\n  }\n\n  public abstract readonly bridgeArn: string;\n  public abstract readonly bridgeName: string;\n  public abstract readonly bridgeType: BridgeType;\n  public abstract readonly bridgeState?: string;\n  public abstract readonly isFailoverEnabled?: boolean;\n\n  /** A reference to this Bridge resource. */\n  public get bridgeRef(): BridgeReference {\n    return { bridgeArn: this.bridgeArn };\n  }\n\n  /**\n   * Create a CloudWatch metric for this bridge.\n   */\n  public metric(metricName: string, props?: MetricOptions): Metric {\n    return new Metric({\n      metricName,\n      namespace: 'AWS/MediaConnect',\n      ...props,\n      dimensionsMap: {\n        BridgeARN: this.bridgeArn,\n        ...props?.dimensionsMap,\n      },\n    }).attachTo(this);\n  }\n\n  /**\n   * Metric for the bitrate of a specific bridge source.\n   */\n  public metricSourceBitrate(bridgeSourceName: string, props?: MetricOptions): Metric {\n    const metricName = this.bridgeType.value === BridgeType.EGRESS_BRIDGE.value\n      ? 'EgressBridgeSourceBitRate'\n      : 'IngressBridgeSourceBitRate';\n    return new Metric({\n      metricName,\n      namespace: 'AWS/MediaConnect',\n      statistic: 'avg',\n      period: Duration.seconds(60),\n      unit: Unit.BITS_PER_SECOND,\n      ...props,\n      dimensionsMap: {\n        BridgeARN: this.bridgeArn,\n        BridgeSourceName: bridgeSourceName,\n        ...props?.dimensionsMap,\n      },\n    }).attachTo(this);\n  }\n\n  /**\n   * Metric for the percentage of packets lost on a specific bridge source.\n   */\n  public metricSourcePacketLossPercent(bridgeSourceName: string, props?: MetricOptions): Metric {\n    const metricName = this.bridgeType.value === BridgeType.EGRESS_BRIDGE.value\n      ? 'EgressBridgeSourcePacketLossPercent'\n      : 'IngressBridgeSourcePacketLossPercent';\n    return new Metric({\n      metricName,\n      namespace: 'AWS/MediaConnect',\n      statistic: 'avg',\n      period: Duration.seconds(60),\n      unit: Unit.PERCENT,\n      ...props,\n      dimensionsMap: {\n        BridgeARN: this.bridgeArn,\n        BridgeSourceName: bridgeSourceName,\n        ...props?.dimensionsMap,\n      },\n    }).attachTo(this);\n  }\n\n  /**\n   * Metric for the total number of times the bridge switches between sources\n   * when using the `FAILOVER` failover mode.\n   */\n  public metricFailoverSwitches(props?: MetricOptions): Metric {\n    const metricName = this.bridgeType.value === BridgeType.EGRESS_BRIDGE.value\n      ? 'EgressBridgeFailoverSwitches'\n      : 'IngressBridgeFailoverSwitches';\n    return this.metric(metricName, {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.COUNT,\n      ...props,\n    });\n  }\n\n  /**\n   * Add a network output to this bridge (for egress bridges only).\n   *\n   * @param id Construct id for the new BridgeOutput\n   * @param networkOutput The named output to add. The `name` is the output's identity on the bridge and must be unique among outputs.\n   */\n  public addOutput(id: string, networkOutput: BridgeNetworkOutput): IBridgeOutput {\n    if (this.bridgeType.value !== BridgeType.EGRESS_BRIDGE.value) {\n      throw new ValidationError(\n        lit`BridgeEgressOnly`,\n        `addOutput can only be called on egress bridges, got '${this.bridgeType.value}'`,\n        this,\n      );\n    }\n\n    return new BridgeOutput(this, id, {\n      bridgeOutputName: networkOutput.name,\n      bridge: this,\n      output: networkOutput.output,\n    });\n  }\n}\n\n/**\n * Defines a AWS Elemental MediaConnect Bridge\n */\n@propertyInjectable\nexport class Bridge extends BridgeBase implements IBridge {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-mediaconnect-alpha.Bridge';\n\n  public readonly bridgeArn: string;\n  public readonly bridgeName: string;\n  public readonly bridgeType: BridgeType;\n  public readonly bridgeState?: string;\n  public readonly isFailoverEnabled?: boolean = false;\n\n  constructor(scope: Construct, id: string, props: BridgeProps) {\n    super(scope, id, {\n      physicalName: props?.bridgeName ?? Lazy.string({ produce: () => Names.uniqueResourceName(this, { maxLength: 64 }) }),\n    });\n\n    // Validate bridge name if provided\n    if (props.bridgeName != null && props.bridgeName !== '' && !Token.isUnresolved(props.bridgeName)) {\n      if (props.bridgeName.length > 64) {\n        throw new ValidationError(lit`BridgeNameLength`, `Bridge name must be between 1 and 64 characters, got ${props.bridgeName.length}`, this);\n      }\n      if (!/^[a-zA-Z0-9-]+$/.test(props.bridgeName)) {\n        throw new ValidationError(lit`BridgeNameFormat`, `Bridge name must contain only alphanumeric characters and hyphens, got '${props.bridgeName}'`, this);\n      }\n    }\n\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    this.isFailoverEnabled = props.sourceFailoverConfig?._isEnabled ?? false;\n\n    const config = props.config;\n    const configBind = config._bind();\n    const ingress = configBind.ingressConfig ? {\n      ingressGatewayBridge: {\n        maxBitrate: configBind.ingressConfig.maxBitrate.toBps(),\n        maxOutputs: configBind.ingressConfig.maxOutputs,\n      },\n      sources: configBind.ingressConfig.networkSources.map(input => {\n        return {\n          networkSource: {\n            name: input.name,\n            multicastIp: input.source.multicastIp,\n            networkName: input.source.network.name,\n            port: input.source.port,\n            protocol: input.source.protocol.value,\n            multicastSourceSettings: {\n              multicastSourceIp: input.source.multicastSourceIp,\n            },\n          },\n        };\n      }),\n    } : undefined;\n    const egress = configBind.egressConfig ? {\n      egressGatewayBridge: {\n        maxBitrate: configBind.egressConfig.maxBitrate.toBps(),\n      },\n      sources: configBind.egressConfig.flowSources.map(input => this.formatBridgeFlowSource(input)),\n      outputs: configBind.egressConfig.networkOutputs.map(no => ({\n        networkOutput: { name: no.name, ...no.output._bind() },\n      })),\n    } : undefined;\n\n    const bridge = new CfnBridge(this, 'Resource', {\n      name: this.physicalName,\n      placementArn: props.gateway.gatewayArn,\n      ingressGatewayBridge: ingress?.ingressGatewayBridge,\n      egressGatewayBridge: egress?.egressGatewayBridge,\n      sources: ingress?.sources ?? egress?.sources ?? [],\n      outputs: egress?.outputs,\n      sourceFailoverConfig: props.sourceFailoverConfig?._bind(),\n    });\n\n    this.bridgeArn = bridge.attrBridgeArn;\n    this.bridgeName = this.physicalName;\n    this.bridgeState = bridge.attrBridgeState;\n    this.bridgeType = configBind.bridgeType;\n  }\n\n  /**\n   * Format bridge flow source into BridgeSourceProperty format\n   */\n  private formatBridgeFlowSource(input: BridgeFlowInput): CfnBridge.BridgeSourceProperty {\n    return {\n      flowSource: {\n        flowArn: input.source.flow.flowArn,\n        name: input.name,\n        flowVpcInterfaceAttachment: input.source.vpcInterface ? {\n          vpcInterfaceName: input.source.vpcInterface.name,\n        } : undefined,\n      },\n    };\n  }\n}\n"]}