@aws-cdk/aws-medialive-alpha 2.268.0-alpha.0

package/lib/destinations.js

@@ -0,0 +1,455 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaConnectRouterSettings = exports.MediaPackageV2Destination = exports.MediaPackageV2EndpointId = exports.SrtDestination = exports.RtmpDestination = exports.UdpOutputDestination = exports.S3OutputDestination = exports.OutputDestination = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+/**
+ * Validate a network port (1–65535), unless tokenized.
+ * @internal
+ */
+function validatePort(port) {
+    if (!aws_cdk_lib_1.Token.isUnresolved(port) && (!Number.isInteger(port) || port < 1 || port > 65535)) {
+        throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `InvalidPort`, `port must be an integer between 1 and 65535, got ${JSON.stringify(port)}`);
+    }
+}
+/** @internal */
+function s3Url(bucket, prefix) {
+    return `s3ssl://${bucket.bucketName}${prefix ? `/${prefix}` : ''}`;
+}
+/**
+ * A general URL-based output destination — an S3 bucket or an HTTP(S) endpoint.
+ *
+ * Used by HLS, MS Smooth, and CMAF Ingest output groups. Each output group's `destinations`
+ * prop is typed to the destination valid for its protocol, so an invalid pairing (e.g. a UDP
+ * destination on an HLS group) is a compile-time error rather than a deploy-time failure.
+ */
+class OutputDestination {
+    destUrl;
+    bucket;
+    options;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.OutputDestination", version: "2.268.0-alpha.0" };
+    /** Deliver to an S3 bucket (auto-grants write to the channel role). */
+    static toBucket(bucket, prefix) {
+        return new OutputDestination(s3Url(bucket, prefix), bucket);
+    }
+    /** Deliver to a raw URL — typically an `https://` origin (or an `s3ssl://` path). */
+    static url(url, options) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_OutputDestinationOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.url);
+            }
+            throw error;
+        }
+        return new OutputDestination(url, undefined, options);
+    }
+    constructor(destUrl, bucket, options) {
+        this.destUrl = destUrl;
+        this.bucket = bucket;
+        this.options = options;
+    }
+    /** @internal */
+    _bind() {
+        return { url: this.destUrl, username: this.options?.username, passwordParam: this.options?.password?.parameterName };
+    }
+    /** @internal */
+    _grantPermissions(role) {
+        this.bucket?.grantReadWrite(role);
+        this.options?.password?.grantRead(role);
+    }
+}
+exports.OutputDestination = OutputDestination;
+/**
+ * A destination for an Archive or Frame Capture output group — always an S3 bucket.
+ */
+class S3OutputDestination {
+    destUrl;
+    bucket;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.S3OutputDestination", version: "2.268.0-alpha.0" };
+    /** Deliver to an S3 bucket (auto-grants write to the channel role). */
+    static toBucket(bucket, prefix) {
+        return new S3OutputDestination(s3Url(bucket, prefix), bucket);
+    }
+    /** Deliver to a raw `s3ssl://` path (escape hatch when you don't have a bucket construct). */
+    static url(url) {
+        return new S3OutputDestination(url);
+    }
+    constructor(destUrl, bucket) {
+        this.destUrl = destUrl;
+        this.bucket = bucket;
+    }
+    /** @internal */
+    _bind() {
+        return { url: this.destUrl };
+    }
+    /** @internal */
+    _grantPermissions(role) {
+        this.bucket?.grantReadWrite(role);
+    }
+}
+exports.S3OutputDestination = S3OutputDestination;
+/**
+ * A destination for a UDP output group — a UDP or RTP transport endpoint.
+ */
+class UdpOutputDestination {
+    destUrl;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.UdpOutputDestination", version: "2.268.0-alpha.0" };
+    /** Deliver over UDP — builds `udp://address:port`. */
+    static udp(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_TransportOutputDestinationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.udp);
+            }
+            throw error;
+        }
+        validatePort(props.port);
+        return new UdpOutputDestination(`udp://${props.address}:${props.port}`);
+    }
+    /** Deliver over RTP — builds `rtp://address:port`. */
+    static rtp(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_TransportOutputDestinationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.rtp);
+            }
+            throw error;
+        }
+        validatePort(props.port);
+        return new UdpOutputDestination(`rtp://${props.address}:${props.port}`);
+    }
+    /** Deliver to a raw transport URL (escape hatch). */
+    static url(url) {
+        return new UdpOutputDestination(url);
+    }
+    constructor(destUrl) {
+        this.destUrl = destUrl;
+    }
+    /** @internal */
+    _bind() {
+        return { url: this.destUrl };
+    }
+    /** @internal */
+    _grantPermissions(_role) { }
+}
+exports.UdpOutputDestination = UdpOutputDestination;
+/**
+ * A destination for an RTMP output group. Use the static factory methods to create.
+ */
+class RtmpDestination {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.RtmpDestination", version: "2.268.0-alpha.0" };
+    /**
+     * Create an RTMP destination.
+     * @param url The RTMP endpoint URL (e.g. rtmp://host/appname).
+     * @param streamName The stream name (stream key).
+     * @param options Optional credentials.
+     */
+    static url(url, streamName, options) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_OutputDestinationOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.url);
+            }
+            throw error;
+        }
+        return new UrlRtmpDestination(url, streamName, options);
+    }
+    /** @internal - Grant the channel role read access to the password parameter, if configured. */
+    _grantPermissions(_role) { }
+}
+exports.RtmpDestination = RtmpDestination;
+/** @internal */
+class UrlRtmpDestination extends RtmpDestination {
+    url;
+    streamName;
+    options;
+    constructor(url, streamName, options) {
+        super();
+        this.url = url;
+        this.streamName = streamName;
+        this.options = options;
+    }
+    _bind() {
+        return {
+            url: this.url,
+            streamName: this.streamName,
+            username: this.options?.username,
+            passwordParam: this.options?.password?.parameterName,
+        };
+    }
+    _grantPermissions(role) {
+        this.options?.password?.grantRead(role);
+    }
+}
+/**
+ * A destination for an SRT output group. Use the static factory methods to create.
+ */
+class SrtDestination {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.SrtDestination", version: "2.268.0-alpha.0" };
+    /** Create a caller-mode SRT destination. MediaLive connects to the remote listener. */
+    static caller(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_SrtCallerDestinationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.caller);
+            }
+            throw error;
+        }
+        validatePort(props.port);
+        return new SrtCallerDestination(`srt://${props.address}:${props.port}`, props.streamId, props.encryptionPassphraseSecret);
+    }
+    /**
+     * Create a caller-mode SRT destination from a full SRT URL.
+     *
+     * Use this when you already have a URL rather than a separate host and port — for example a
+     * MediaConnect Router Input's ingest endpoint (`routerInput.endpoints[0].url`).
+     */
+    static callerUrl(url, options) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_SrtCallerUrlOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.callerUrl);
+            }
+            throw error;
+        }
+        return new SrtCallerDestination(url, options.streamId, options.encryptionPassphraseSecret);
+    }
+    /** Create a listener-mode SRT destination. MediaLive listens for incoming connections. */
+    static listener(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_SrtListenerDestinationProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.listener);
+            }
+            throw error;
+        }
+        return new SrtListenerDestination(props);
+    }
+    /** @internal - Grant permissions for encryption secrets. */
+    _grantPermissions(_role) { }
+}
+exports.SrtDestination = SrtDestination;
+/** @internal */
+class SrtCallerDestination extends SrtDestination {
+    url;
+    streamId;
+    encryptionPassphraseSecret;
+    constructor(url, streamId, encryptionPassphraseSecret) {
+        super();
+        this.url = url;
+        this.streamId = streamId;
+        this.encryptionPassphraseSecret = encryptionPassphraseSecret;
+    }
+    _bind() {
+        return {
+            url: this.url,
+            connectionMode: 'CALLER',
+            streamId: this.streamId,
+            encryptionPassphraseSecretArn: this.encryptionPassphraseSecret.secretArn,
+        };
+    }
+    _grantPermissions(role) {
+        this.encryptionPassphraseSecret.grantRead(role);
+    }
+}
+/** @internal */
+class SrtListenerDestination extends SrtDestination {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+        if (!aws_cdk_lib_1.Token.isUnresolved(props.listenerPort) && (!Number.isInteger(props.listenerPort)
+            || props.listenerPort < 5000 || props.listenerPort > 5200)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `SrtListenerPort`, `SRT listener port must be an integer between 5000 and 5200, got ${JSON.stringify(props.listenerPort)}`);
+        }
+    }
+    _bind() {
+        return {
+            connectionMode: 'LISTENER',
+            listenerPort: this.props.listenerPort,
+            streamId: this.props.streamId,
+            encryptionPassphraseSecretArn: this.props.encryptionPassphraseSecret.secretArn,
+        };
+    }
+    _grantPermissions(role) {
+        this.props.encryptionPassphraseSecret.grantRead(role);
+    }
+}
+/**
+ * The pipeline endpoint for a MediaPackage V2 destination.
+ */
+class MediaPackageV2EndpointId {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.MediaPackageV2EndpointId", version: "2.268.0-alpha.0" };
+    /** Pipeline 0 endpoint */
+    static ENDPOINT_1 = new MediaPackageV2EndpointId('ENDPOINT_1');
+    /** Pipeline 1 endpoint */
+    static ENDPOINT_2 = new MediaPackageV2EndpointId('ENDPOINT_2');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new MediaPackageV2EndpointId(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.MediaPackageV2EndpointId = MediaPackageV2EndpointId;
+/**
+ * A MediaPackage V2 destination for a MediaLive output group.
+ * Use the static factory method to create.
+ */
+class MediaPackageV2Destination {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.MediaPackageV2Destination", version: "2.268.0-alpha.0" };
+    /**
+     * Create a MediaPackage V2 destination.
+     *
+     * The region is resolved from the channel's `region` property. Import the MediaPackage V2
+     * channel with its region (e.g. via `fromChannelAttributes`) for cross-region delivery.
+     *
+     * @param channel The MediaPackage V2 channel to send output to.
+     * @param endpointId The pipeline endpoint to send to. When omitted, `channelEndpointId` and the
+     * region are left unset and MediaLive maps the pipeline automatically (same-region only).
+     */
+    static channel(channel, endpointId) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_MediaPackageV2EndpointId(endpointId);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.channel);
+            }
+            throw error;
+        }
+        return new DefaultMediaPackageV2Destination(channel, endpointId);
+    }
+    /** @internal - Grant ingest permissions to the channel role. */
+    _grantPermissions(_role) { }
+}
+exports.MediaPackageV2Destination = MediaPackageV2Destination;
+/** @internal */
+class DefaultMediaPackageV2Destination extends MediaPackageV2Destination {
+    mpChannel;
+    endpointId;
+    constructor(mpChannel, endpointId) {
+        super();
+        this.mpChannel = mpChannel;
+        this.endpointId = endpointId;
+    }
+    _bind() {
+        return {
+            channelName: this.mpChannel.channelName,
+            channelGroup: this.mpChannel.channelGroupName,
+            channelEndpointId: this.endpointId?.value,
+            // MediaLive requires an endpoint id whenever a region is set, so only emit the region
+            // when an endpoint is provided. Omitting both selects same-region pipeline auto-mapping.
+            mediaPackageRegionName: this.endpointId !== undefined ? this.mpChannel.region : undefined,
+        };
+    }
+    _grantPermissions(role) {
+        this.mpChannel.grants.ingest(role);
+    }
+}
+/** @internal */
+function renderRouterPipeline(config) {
+    return config?.encryptionSecret !== undefined
+        ? { encryptionType: 'SECRETS_MANAGER', secretArn: config.encryptionSecret.secretArn }
+        : { encryptionType: 'AUTOMATIC' };
+}
+/**
+ * Transit-encryption settings for a MediaConnect Router output group, applied per channel pipeline.
+ *
+ * Omit the output group's `routerSettings` entirely for AUTOMATIC (service-managed) encryption on
+ * every pipeline. Use `shared()` to apply one secret across all pipelines, or `perPipeline()` to
+ * control each pipeline independently.
+ */
+class MediaConnectRouterSettings {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.MediaConnectRouterSettings", version: "2.268.0-alpha.0" };
+    /**
+     * Apply the same settings to every pipeline.
+     *
+     * @param settings the settings to apply to all pipelines. Omit `encryptionSecret` for AUTOMATIC.
+     */
+    static shared(settings = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_MediaConnectRouterPipelineConfig(settings);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.shared);
+            }
+            throw error;
+        }
+        return new SharedMediaConnectRouterSettings(settings);
+    }
+    /**
+     * Configure each pipeline independently. An omitted pipeline uses AUTOMATIC encryption.
+     */
+    static perPipeline(settings) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_MediaConnectRouterPerPipelineSettings(settings);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.perPipeline);
+            }
+            throw error;
+        }
+        return new PerPipelineMediaConnectRouterSettings(settings);
+    }
+}
+exports.MediaConnectRouterSettings = MediaConnectRouterSettings;
+/** @internal */
+class SharedMediaConnectRouterSettings extends MediaConnectRouterSettings {
+    settings;
+    constructor(settings) {
+        super();
+        this.settings = settings;
+    }
+    _bind(pipelineCount) {
+        const entry = renderRouterPipeline(this.settings);
+        return Array.from({ length: pipelineCount }, () => entry);
+    }
+    _secrets() {
+        return this.settings.encryptionSecret !== undefined ? [this.settings.encryptionSecret] : [];
+    }
+}
+/** @internal */
+class PerPipelineMediaConnectRouterSettings extends MediaConnectRouterSettings {
+    settings;
+    constructor(settings) {
+        super();
+        this.settings = settings;
+    }
+    _bind(pipelineCount) {
+        if (pipelineCount === 1 && this.settings.pipeline1 !== undefined) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `MediaConnectRouterPipelineOne`, 'pipeline1 settings are not valid on a SINGLE_PIPELINE channel; use ChannelClass.STANDARD or remove pipeline1');
+        }
+        const result = [renderRouterPipeline(this.settings.pipeline0)];
+        if (pipelineCount === 2) {
+            result.push(renderRouterPipeline(this.settings.pipeline1));
+        }
+        return result;
+    }
+    _secrets() {
+        return [this.settings.pipeline0?.encryptionSecret, this.settings.pipeline1?.encryptionSecret]
+            .filter((s) => s !== undefined);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"destinations.js","sourceRoot":"","sources":["destinations.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IChannel as IMediaPackageV2Channel } from '@aws-cdk/aws-mediapackagev2-alpha';\nimport { Token, UnscopedValidationError } from 'aws-cdk-lib';\nimport type { IRole } from 'aws-cdk-lib/aws-iam';\nimport type { CfnChannel } from 'aws-cdk-lib/aws-medialive';\nimport type { IBucket } from 'aws-cdk-lib/aws-s3';\nimport type { ISecret } from 'aws-cdk-lib/aws-secretsmanager';\nimport type { IStringParameter } from 'aws-cdk-lib/aws-ssm';\nimport { lit } from 'aws-cdk-lib/core/lib/helpers-internal';\n\n/**\n * Validate a network port (1–65535), unless tokenized.\n * @internal\n */\nfunction validatePort(port: number): void {\n  if (!Token.isUnresolved(port) && (!Number.isInteger(port) || port < 1 || port > 65535)) {\n    throw new UnscopedValidationError(lit`InvalidPort`, `port must be an integer between 1 and 65535, got ${JSON.stringify(port)}`);\n  }\n}\n\n/**\n * A destination address (IP or host) and port for a transport-stream output.\n */\nexport interface TransportOutputDestinationProps {\n  /** The destination address — a unicast or multicast IP, or a hostname. */\n  readonly address: string;\n  /** The destination port. */\n  readonly port: number;\n}\n\n/**\n * Options for a URL-based output destination.\n */\nexport interface OutputDestinationOptions {\n  /**\n   * The username for accessing the downstream system.\n   * @default - no credentials\n   */\n  readonly username?: string;\n  /**\n   * An SSM String Parameter holding the password for accessing the downstream system. MediaLive\n   * reads it from Parameter Store at channel runtime, so the channel role is granted read access.\n   * @default - no credentials\n   */\n  readonly password?: IStringParameter;\n}\n\n/** @internal */\nfunction s3Url(bucket: IBucket, prefix?: string): string {\n  return `s3ssl://${bucket.bucketName}${prefix ? `/${prefix}` : ''}`;\n}\n\n/**\n * A general URL-based output destination — an S3 bucket or an HTTP(S) endpoint.\n *\n * Used by HLS, MS Smooth, and CMAF Ingest output groups. Each output group's `destinations`\n * prop is typed to the destination valid for its protocol, so an invalid pairing (e.g. a UDP\n * destination on an HLS group) is a compile-time error rather than a deploy-time failure.\n */\nexport class OutputDestination {\n  /** Deliver to an S3 bucket (auto-grants write to the channel role). */\n  public static toBucket(bucket: IBucket, prefix?: string): OutputDestination {\n    return new OutputDestination(s3Url(bucket, prefix), bucket);\n  }\n  /** Deliver to a raw URL — typically an `https://` origin (or an `s3ssl://` path). */\n  public static url(url: string, options?: OutputDestinationOptions): OutputDestination {\n    return new OutputDestination(url, undefined, options);\n  }\n  private constructor(\n    private readonly destUrl: string,\n    private readonly bucket?: IBucket,\n    private readonly options?: OutputDestinationOptions,\n  ) {}\n  /** @internal */\n  public _bind() {\n    return { url: this.destUrl, username: this.options?.username, passwordParam: this.options?.password?.parameterName };\n  }\n  /** @internal */\n  public _grantPermissions(role: IRole): void {\n    this.bucket?.grantReadWrite(role);\n    this.options?.password?.grantRead(role);\n  }\n}\n\n/**\n * A destination for an Archive or Frame Capture output group — always an S3 bucket.\n */\nexport class S3OutputDestination {\n  /** Deliver to an S3 bucket (auto-grants write to the channel role). */\n  public static toBucket(bucket: IBucket, prefix?: string): S3OutputDestination {\n    return new S3OutputDestination(s3Url(bucket, prefix), bucket);\n  }\n  /** Deliver to a raw `s3ssl://` path (escape hatch when you don't have a bucket construct). */\n  public static url(url: string): S3OutputDestination {\n    return new S3OutputDestination(url);\n  }\n  private constructor(private readonly destUrl: string, private readonly bucket?: IBucket) {}\n  /** @internal */\n  public _bind() {\n    return { url: this.destUrl };\n  }\n  /** @internal */\n  public _grantPermissions(role: IRole): void {\n    this.bucket?.grantReadWrite(role);\n  }\n}\n\n/**\n * A destination for a UDP output group — a UDP or RTP transport endpoint.\n */\nexport class UdpOutputDestination {\n  /** Deliver over UDP — builds `udp://address:port`. */\n  public static udp(props: TransportOutputDestinationProps): UdpOutputDestination {\n    validatePort(props.port);\n    return new UdpOutputDestination(`udp://${props.address}:${props.port}`);\n  }\n  /** Deliver over RTP — builds `rtp://address:port`. */\n  public static rtp(props: TransportOutputDestinationProps): UdpOutputDestination {\n    validatePort(props.port);\n    return new UdpOutputDestination(`rtp://${props.address}:${props.port}`);\n  }\n  /** Deliver to a raw transport URL (escape hatch). */\n  public static url(url: string): UdpOutputDestination {\n    return new UdpOutputDestination(url);\n  }\n  private constructor(private readonly destUrl: string) {}\n  /** @internal */\n  public _bind() {\n    return { url: this.destUrl };\n  }\n  /** @internal */\n  public _grantPermissions(_role: IRole): void {}\n}\n\n/**\n * A destination for an RTMP output group. Use the static factory methods to create.\n */\nexport abstract class RtmpDestination {\n  /**\n   * Create an RTMP destination.\n   * @param url The RTMP endpoint URL (e.g. rtmp://host/appname).\n   * @param streamName The stream name (stream key).\n   * @param options Optional credentials.\n   */\n  public static url(url: string, streamName: string, options?: OutputDestinationOptions): RtmpDestination {\n    return new UrlRtmpDestination(url, streamName, options);\n  }\n\n  /** @internal */\n  public abstract _bind(): { url: string; streamName: string; username?: string; passwordParam?: string };\n\n  /** @internal - Grant the channel role read access to the password parameter, if configured. */\n  public _grantPermissions(_role: IRole): void {}\n}\n\n/** @internal */\nclass UrlRtmpDestination extends RtmpDestination {\n  constructor(\n    private readonly url: string,\n    private readonly streamName: string,\n    private readonly options?: OutputDestinationOptions,\n  ) { super(); }\n  public _bind() {\n    return {\n      url: this.url,\n      streamName: this.streamName,\n      username: this.options?.username,\n      passwordParam: this.options?.password?.parameterName,\n    };\n  }\n  public override _grantPermissions(role: IRole): void {\n    this.options?.password?.grantRead(role);\n  }\n}\n\n/**\n * SRT caller destination properties.\n */\nexport interface SrtCallerDestinationProps {\n  /** The address (IP or host) of the SRT listener to connect to. */\n  readonly address: string;\n  /** The port of the SRT listener to connect to. */\n  readonly port: number;\n  /**\n   * The stream ID for the SRT connection.\n   * @default - no stream ID\n   */\n  readonly streamId?: string;\n  /**\n   * The Secrets Manager secret containing the encryption passphrase.\n   *\n   * [disable-awslint:prefer-ref-interface]\n   */\n  readonly encryptionPassphraseSecret: ISecret;\n}\n\n/**\n * Options for a URL-based SRT caller destination (`SrtDestination.callerUrl`).\n */\nexport interface SrtCallerUrlOptions {\n  /**\n   * The stream ID for the SRT connection.\n   * @default - no stream ID\n   */\n  readonly streamId?: string;\n  /**\n   * The Secrets Manager secret containing the encryption passphrase.\n   *\n   * [disable-awslint:prefer-ref-interface]\n   */\n  readonly encryptionPassphraseSecret: ISecret;\n}\n\n/**\n * SRT listener destination properties.\n *\n * In listener mode, MediaLive opens a socket on `listenerPort` and waits for the downstream\n * system to connect. The downstream system needs the channel's outbound IP and this port —\n * AWS does not require (or use) a destination URL in listener mode.\n */\nexport interface SrtListenerDestinationProps {\n  /** The port that MediaLive will listen on. AWS reserves the range 5000–5200 for SRT listener output. */\n  readonly listenerPort: number;\n  /**\n   * The stream ID for the SRT connection.\n   * @default - no stream ID\n   */\n  readonly streamId?: string;\n  /**\n   * The Secrets Manager secret containing the encryption passphrase.\n   *\n   * [disable-awslint:prefer-ref-interface]\n   */\n  readonly encryptionPassphraseSecret: ISecret;\n}\n\n/**\n * A destination for an SRT output group. Use the static factory methods to create.\n */\nexport abstract class SrtDestination {\n  /** Create a caller-mode SRT destination. MediaLive connects to the remote listener. */\n  public static caller(props: SrtCallerDestinationProps): SrtDestination {\n    validatePort(props.port);\n    return new SrtCallerDestination(`srt://${props.address}:${props.port}`, props.streamId, props.encryptionPassphraseSecret);\n  }\n  /**\n   * Create a caller-mode SRT destination from a full SRT URL.\n   *\n   * Use this when you already have a URL rather than a separate host and port — for example a\n   * MediaConnect Router Input's ingest endpoint (`routerInput.endpoints[0].url`).\n   */\n  public static callerUrl(url: string, options: SrtCallerUrlOptions): SrtDestination {\n    return new SrtCallerDestination(url, options.streamId, options.encryptionPassphraseSecret);\n  }\n  /** Create a listener-mode SRT destination. MediaLive listens for incoming connections. */\n  public static listener(props: SrtListenerDestinationProps): SrtDestination {\n    return new SrtListenerDestination(props);\n  }\n\n  /** @internal */\n  public abstract _bind(): { url?: string; connectionMode?: string;\n    encryptionPassphraseSecretArn?: string;\n    listenerPort?: number; streamId?: string; };\n\n  /** @internal - Grant permissions for encryption secrets. */\n  public _grantPermissions(_role: IRole): void {}\n}\n\n/** @internal */\nclass SrtCallerDestination extends SrtDestination {\n  constructor(\n    private readonly url: string,\n    private readonly streamId: string | undefined,\n    private readonly encryptionPassphraseSecret: ISecret,\n  ) { super(); }\n  public _bind() {\n    return {\n      url: this.url,\n      connectionMode: 'CALLER',\n      streamId: this.streamId,\n      encryptionPassphraseSecretArn: this.encryptionPassphraseSecret.secretArn,\n    };\n  }\n  public override _grantPermissions(role: IRole): void {\n    this.encryptionPassphraseSecret.grantRead(role);\n  }\n}\n\n/** @internal */\nclass SrtListenerDestination extends SrtDestination {\n  constructor(private readonly props: SrtListenerDestinationProps) {\n    super();\n    if (!Token.isUnresolved(props.listenerPort) && (!Number.isInteger(props.listenerPort)\n      || props.listenerPort < 5000 || props.listenerPort > 5200)) {\n      throw new UnscopedValidationError(lit`SrtListenerPort`, `SRT listener port must be an integer between 5000 and 5200, got ${JSON.stringify(props.listenerPort)}`);\n    }\n  }\n  public _bind() {\n    return {\n      connectionMode: 'LISTENER',\n      listenerPort: this.props.listenerPort,\n      streamId: this.props.streamId,\n      encryptionPassphraseSecretArn: this.props.encryptionPassphraseSecret.secretArn,\n    };\n  }\n  public override _grantPermissions(role: IRole): void {\n    this.props.encryptionPassphraseSecret.grantRead(role);\n  }\n}\n\n/**\n * The pipeline endpoint for a MediaPackage V2 destination.\n */\nexport class MediaPackageV2EndpointId {\n  /** Pipeline 0 endpoint */\n  public static readonly ENDPOINT_1 = new MediaPackageV2EndpointId('ENDPOINT_1');\n  /** Pipeline 1 endpoint */\n  public static readonly ENDPOINT_2 = new MediaPackageV2EndpointId('ENDPOINT_2');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): MediaPackageV2EndpointId {\n    return new MediaPackageV2EndpointId(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/**\n * A MediaPackage V2 destination for a MediaLive output group.\n * Use the static factory method to create.\n */\nexport abstract class MediaPackageV2Destination {\n  /**\n   * Create a MediaPackage V2 destination.\n   *\n   * The region is resolved from the channel's `region` property. Import the MediaPackage V2\n   * channel with its region (e.g. via `fromChannelAttributes`) for cross-region delivery.\n   *\n   * @param channel The MediaPackage V2 channel to send output to.\n   * @param endpointId The pipeline endpoint to send to. When omitted, `channelEndpointId` and the\n   * region are left unset and MediaLive maps the pipeline automatically (same-region only).\n   */\n  public static channel(channel: IMediaPackageV2Channel, endpointId?: MediaPackageV2EndpointId): MediaPackageV2Destination {\n    return new DefaultMediaPackageV2Destination(channel, endpointId);\n  }\n\n  /** @internal */\n  public abstract _bind(): { channelName: string; channelGroup: string; channelEndpointId?: string; mediaPackageRegionName?: string };\n\n  /** @internal - Grant ingest permissions to the channel role. */\n  public _grantPermissions(_role: IRole): void {}\n}\n\n/** @internal */\nclass DefaultMediaPackageV2Destination extends MediaPackageV2Destination {\n  constructor(\n    private readonly mpChannel: IMediaPackageV2Channel,\n    private readonly endpointId?: MediaPackageV2EndpointId,\n  ) { super(); }\n  public _bind() {\n    return {\n      channelName: this.mpChannel.channelName,\n      channelGroup: this.mpChannel.channelGroupName,\n      channelEndpointId: this.endpointId?.value,\n      // MediaLive requires an endpoint id whenever a region is set, so only emit the region\n      // when an endpoint is provided. Omitting both selects same-region pipeline auto-mapping.\n      mediaPackageRegionName: this.endpointId !== undefined ? this.mpChannel.region : undefined,\n    };\n  }\n  public override _grantPermissions(role: IRole): void {\n    this.mpChannel.grants.ingest(role);\n  }\n}\n\n/**\n * Per-pipeline settings for a MediaConnect Router output destination.\n *\n * Today this carries only transit encryption, but it is a struct so that future per-pipeline\n * MediaConnect Router settings can be added without an API break.\n */\nexport interface MediaConnectRouterPipelineConfig {\n  /**\n   * A Secrets Manager secret holding the transit-encryption passphrase. When set, the pipeline\n   * uses `SECRETS_MANAGER` encryption; the channel role is granted read access to the secret.\n   *\n   * @default - AUTOMATIC (service-managed) transit encryption\n   */\n  readonly encryptionSecret?: ISecret;\n}\n\n/**\n * Per-pipeline settings for `MediaConnectRouterSettings.perPipeline()`.\n *\n * MediaLive maps a channel's pipelines to MediaConnect Router output destinations positionally;\n * the console labels them \"Destination A\" (pipeline 0) and \"Destination B\" (pipeline 1). An\n * omitted pipeline uses AUTOMATIC transit encryption.\n */\nexport interface MediaConnectRouterPerPipelineSettings {\n  /**\n   * Settings for pipeline 0 (\"Destination A\" in the MediaLive console).\n   * @default - AUTOMATIC transit encryption\n   */\n  readonly pipeline0?: MediaConnectRouterPipelineConfig;\n  /**\n   * Settings for pipeline 1 (\"Destination B\" in the console). STANDARD channels only —\n   * SINGLE_PIPELINE channels have no second pipeline.\n   * @default - AUTOMATIC transit encryption\n   */\n  readonly pipeline1?: MediaConnectRouterPipelineConfig;\n}\n\n/** @internal */\nfunction renderRouterPipeline(config?: MediaConnectRouterPipelineConfig): CfnChannel.MediaConnectRouterOutputDestinationSettingsProperty {\n  return config?.encryptionSecret !== undefined\n    ? { encryptionType: 'SECRETS_MANAGER', secretArn: config.encryptionSecret.secretArn }\n    : { encryptionType: 'AUTOMATIC' };\n}\n\n/**\n * Transit-encryption settings for a MediaConnect Router output group, applied per channel pipeline.\n *\n * Omit the output group's `routerSettings` entirely for AUTOMATIC (service-managed) encryption on\n * every pipeline. Use `shared()` to apply one secret across all pipelines, or `perPipeline()` to\n * control each pipeline independently.\n */\nexport abstract class MediaConnectRouterSettings {\n  /**\n   * Apply the same settings to every pipeline.\n   *\n   * @param settings the settings to apply to all pipelines. Omit `encryptionSecret` for AUTOMATIC.\n   */\n  public static shared(settings: MediaConnectRouterPipelineConfig = {}): MediaConnectRouterSettings {\n    return new SharedMediaConnectRouterSettings(settings);\n  }\n\n  /**\n   * Configure each pipeline independently. An omitted pipeline uses AUTOMATIC encryption.\n   */\n  public static perPipeline(settings: MediaConnectRouterPerPipelineSettings): MediaConnectRouterSettings {\n    return new PerPipelineMediaConnectRouterSettings(settings);\n  }\n\n  /**\n   * Render the per-pipeline destination settings for the given pipeline count (1 for\n   * SINGLE_PIPELINE, 2 for STANDARD).\n   * @internal\n   */\n  public abstract _bind(pipelineCount: number): CfnChannel.MediaConnectRouterOutputDestinationSettingsProperty[];\n\n  /**\n   * The secrets referenced by these settings, for granting read access to the channel role.\n   * @internal\n   */\n  public abstract _secrets(): ISecret[];\n}\n\n/** @internal */\nclass SharedMediaConnectRouterSettings extends MediaConnectRouterSettings {\n  constructor(private readonly settings: MediaConnectRouterPipelineConfig) { super(); }\n\n  public _bind(pipelineCount: number): CfnChannel.MediaConnectRouterOutputDestinationSettingsProperty[] {\n    const entry = renderRouterPipeline(this.settings);\n    return Array.from({ length: pipelineCount }, () => entry);\n  }\n\n  public _secrets(): ISecret[] {\n    return this.settings.encryptionSecret !== undefined ? [this.settings.encryptionSecret] : [];\n  }\n}\n\n/** @internal */\nclass PerPipelineMediaConnectRouterSettings extends MediaConnectRouterSettings {\n  constructor(private readonly settings: MediaConnectRouterPerPipelineSettings) { super(); }\n\n  public _bind(pipelineCount: number): CfnChannel.MediaConnectRouterOutputDestinationSettingsProperty[] {\n    if (pipelineCount === 1 && this.settings.pipeline1 !== undefined) {\n      throw new UnscopedValidationError(\n        lit`MediaConnectRouterPipelineOne`,\n        'pipeline1 settings are not valid on a SINGLE_PIPELINE channel; use ChannelClass.STANDARD or remove pipeline1',\n      );\n    }\n    const result = [renderRouterPipeline(this.settings.pipeline0)];\n    if (pipelineCount === 2) {\n      result.push(renderRouterPipeline(this.settings.pipeline1));\n    }\n    return result;\n  }\n\n  public _secrets(): ISecret[] {\n    return [this.settings.pipeline0?.encryptionSecret, this.settings.pipeline1?.encryptionSecret]\n      .filter((s): s is ISecret => s !== undefined);\n  }\n}\n"]}