@aws-cdk/aws-mediapackagev2-alpha 2.247.0-alpha.0

package/lib/endpoint.js

@@ -0,0 +1,2010 @@
+"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.OriginEndpoint = exports.Segment = exports.IsmEncryption = exports.TsEncryption = exports.CmafEncryption = exports.EncryptionConfiguration = exports.IsmDrmSystem = exports.TsDrmSystem = exports.CmafDrmSystem = exports.MssManifestLayout = exports.TtmlProfile = exports.DashManifestCompactness = exports.DrmSignalling = exports.DashPeriodTriggers = exports.DashUtcTimingMode = exports.SegmentTemplateFormat = exports.AdMarkerHls = exports.AdMarkerDash = exports.StartTag = exports.DrmSettingsKey = exports.ScteInSegments = exports.ScteMessageType = exports.EndpointErrorConfiguration = exports.PresetSpeke20Video = exports.PresetSpeke20Audio = exports.TsEncryptionMethod = exports.CmafEncryptionMethod = exports.ContainerType = exports.Manifest = exports.ManifestFilter = exports.BitrateExpression = exports.NumericExpression = exports.BitrateFilterKey = exports.TextFilterKey = exports.NumericFilterKey = exports.TrickplayType = exports.VideoDynamicRange = exports.VideoCodec = exports.AudioCodec = 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_mediapackagev2_1 = require("aws-cdk-lib/aws-mediapackagev2");
+const core_1 = require("aws-cdk-lib/core");
+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 origin_endpoint_policy_1 = require("./origin-endpoint-policy");
+const shared_helpers_1 = require("./shared-helpers");
+/**
+ * Accepted audio codec values for manifest filtering.
+ *
+ * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html
+ */
+var AudioCodec;
+(function (AudioCodec) {
+    /** AAC-LC audio codec */
+    AudioCodec["AACL"] = "AACL";
+    /** HE-AAC audio codec */
+    AudioCodec["AACH"] = "AACH";
+    /** Dolby Digital audio codec (include the hyphen) */
+    AudioCodec["AC_3"] = "AC-3";
+    /** Dolby Digital Plus audio codec (include the hyphen) */
+    AudioCodec["EC_3"] = "EC-3";
+})(AudioCodec || (exports.AudioCodec = AudioCodec = {}));
+/**
+ * Accepted video codec values for manifest filtering.
+ *
+ * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html
+ */
+var VideoCodec;
+(function (VideoCodec) {
+    /** H.264/AVC */
+    VideoCodec["H264"] = "H264";
+    /** H.265/HEVC */
+    VideoCodec["H265"] = "H265";
+    /** AV1 */
+    VideoCodec["AV1"] = "AV1";
+})(VideoCodec || (exports.VideoCodec = VideoCodec = {}));
+/**
+ * Accepted video dynamic range values for manifest filtering.
+ *
+ * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html
+ */
+var VideoDynamicRange;
+(function (VideoDynamicRange) {
+    /** Dolby Vision */
+    VideoDynamicRange["DV"] = "dv";
+    /** HDR10 */
+    VideoDynamicRange["HDR10"] = "hdr10";
+    /** Hybrid Log-Gamma */
+    VideoDynamicRange["HLG"] = "hlg";
+    /** Standard Dynamic Range */
+    VideoDynamicRange["SDR"] = "sdr";
+})(VideoDynamicRange || (exports.VideoDynamicRange = VideoDynamicRange = {}));
+/**
+ * Accepted trickplay type values for manifest filtering.
+ *
+ * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html
+ */
+var TrickplayType;
+(function (TrickplayType) {
+    /** I-frame only trick-play */
+    TrickplayType["IFRAME"] = "iframe";
+    /** Image-based trick-play */
+    TrickplayType["IMAGE"] = "image";
+    /** No trick-play */
+    TrickplayType["NONE"] = "none";
+})(TrickplayType || (exports.TrickplayType = TrickplayType = {}));
+/**
+ * Numeric manifest filter keys.
+ *
+ * Use with `ManifestFilter.numeric()`, `ManifestFilter.numericList()`, and `ManifestFilter.numericRange()`.
+ *
+ * Audio and video bitrate filters are not included here because they use the
+ * `Bitrate` class directly via dedicated methods on `ManifestFilter`.
+ *
+ * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html
+ */
+var NumericFilterKey;
+(function (NumericFilterKey) {
+    /**
+     * The number of audio channels.
+     *
+     * Accepted values: range 1–32767, or individual integers.
+     */
+    NumericFilterKey["AUDIO_CHANNELS"] = "audio_channels";
+    /**
+     * The audio sample rate in Hz.
+     *
+     * Accepted values: range 0–2147483647, or individual integers.
+     */
+    NumericFilterKey["AUDIO_SAMPLE_RATE"] = "audio_sample_rate";
+    /**
+     * The height of the trick-play image in pixels (I-frame and image-based trick-play).
+     *
+     * If using with I-frame only trick-play, `TRICKPLAY_HEIGHT` and `VIDEO_HEIGHT`
+     * should have similar values. If they differ, I-frame only tracks might be
+     * removed from the manifest.
+     *
+     * Accepted values: range 1–2147483647, or individual integers.
+     */
+    NumericFilterKey["TRICKPLAY_HEIGHT"] = "trickplay_height";
+    /**
+     * The video frame rate range in NTSC format.
+     *
+     * When filtering for a single value, MediaPackage uses an approximate equals
+     * comparison with an epsilon tolerance of 0.0005.
+     *
+     * Accepted values: range 1–999.999 (up to three decimal places), or individual values.
+     */
+    NumericFilterKey["VIDEO_FRAMERATE"] = "video_framerate";
+    /**
+     * The height of the video in pixels.
+     *
+     * If using with I-frame only trick-play, `TRICKPLAY_HEIGHT` and `VIDEO_HEIGHT`
+     * should have similar values. If they differ, I-frame only tracks might be
+     * removed from the manifest.
+     *
+     * Accepted values: range 1–32767, or individual integers.
+     */
+    NumericFilterKey["VIDEO_HEIGHT"] = "video_height";
+})(NumericFilterKey || (exports.NumericFilterKey = NumericFilterKey = {}));
+/**
+ * Text manifest filter keys for free-form string values.
+ *
+ * Use with `ManifestFilter.text()` and `ManifestFilter.textList()`.
+ *
+ * For keys with fixed accepted values, use the dedicated methods on `ManifestFilter` instead:
+ * - Audio codec: `ManifestFilter.audioCodec()` / `ManifestFilter.audioCodecList()`
+ * - Video codec: `ManifestFilter.videoCodec()` / `ManifestFilter.videoCodecList()`
+ * - Video dynamic range: `ManifestFilter.videoDynamicRange()` / `ManifestFilter.videoDynamicRangeList()`
+ * - Trickplay type: `ManifestFilter.trickplayType()` / `ManifestFilter.trickplayTypeList()`
+ *
+ * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html
+ */
+var TextFilterKey;
+(function (TextFilterKey) {
+    /**
+     * Audio languages or functional codes derived from encoder passthrough.
+     *
+     * Accepted values: arbitrary strings such as ISO-639-1 language codes (not case-sensitive).
+     */
+    TextFilterKey["AUDIO_LANGUAGE"] = "audio_language";
+    /**
+     * The subtitle language or functional codes derived from encoder passthrough.
+     *
+     * Accepted values: arbitrary strings such as ISO-639-1 language codes (not case-sensitive).
+     */
+    TextFilterKey["SUBTITLE_LANGUAGE"] = "subtitle_language";
+})(TextFilterKey || (exports.TextFilterKey = TextFilterKey = {}));
+/**
+ * Bitrate manifest filter keys.
+ *
+ * Use with `ManifestFilter.bitrate()` and `ManifestFilter.bitrateRange()`.
+ *
+ * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html
+ */
+var BitrateFilterKey;
+(function (BitrateFilterKey) {
+    /**
+     * The audio bitrate in bits per second.
+     *
+     * Accepted values: range 0–2147483647, or individual integers.
+     */
+    BitrateFilterKey["AUDIO_BITRATE"] = "audio_bitrate";
+    /**
+     * The video bitrate in bits per second.
+     *
+     * We recommend using only this filter parameter to set the video bitrate.
+     * Do not also set the minimum and maximum video bitrate via the MediaPackage
+     * console or AWS CLI, as your output might be skewed.
+     *
+     * This parameter cannot be used with trick-play streams.
+     *
+     * Accepted values: range 0–2147483647, or individual integers.
+     */
+    BitrateFilterKey["VIDEO_BITRATE"] = "video_bitrate";
+})(BitrateFilterKey || (exports.BitrateFilterKey = BitrateFilterKey = {}));
+/**
+ * Represents a numeric filter expression segment — either a single value or a range.
+ *
+ * Use with `ManifestFilter.numericCombo()` to build filters that combine
+ * ranges and individual values (e.g. `video_height:240-360,720-1080,1440`).
+ */
+class NumericExpression {
+    _expression;
+    _values;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediapackagev2-alpha.NumericExpression", version: "2.247.0-alpha.0" };
+    /**
+     * A single numeric value.
+     */
+    static value(v) {
+        return new NumericExpression(`${v}`, [v]);
+    }
+    /**
+     * An inclusive numeric range.
+     */
+    static range(start, end) {
+        return new NumericExpression(`${start}-${end}`, [start, end]);
+    }
+    constructor(
+    /** @internal */
+    _expression, 
+    /** @internal */
+    _values) {
+        this._expression = _expression;
+        this._values = _values;
+    }
+}
+exports.NumericExpression = NumericExpression;
+/**
+ * Represents a bitrate filter expression segment — either a single value or a range.
+ *
+ * Use with `ManifestFilter.bitrateCombo()` to build filters that combine
+ * ranges and individual bitrate values.
+ */
+class BitrateExpression {
+    _expression;
+    _values;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediapackagev2-alpha.BitrateExpression", version: "2.247.0-alpha.0" };
+    /**
+     * A single bitrate value.
+     */
+    static value(v) {
+        return new BitrateExpression(`${v.toBps()}`, [v.toBps()]);
+    }
+    /**
+     * An inclusive bitrate range.
+     */
+    static range(start, end) {
+        return new BitrateExpression(`${start.toBps()}-${end.toBps()}`, [start.toBps(), end.toBps()]);
+    }
+    constructor(
+    /** @internal */
+    _expression, 
+    /** @internal */
+    _values) {
+        this._expression = _expression;
+        this._values = _values;
+    }
+}
+exports.BitrateExpression = BitrateExpression;
+/**
+ * Enables you to create filters for your Origin Endpoint.
+ *
+ * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filtering.html
+ */
+class ManifestFilter {
+    filterString;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediapackagev2-alpha.ManifestFilter", version: "2.247.0-alpha.0" };
+    /**
+     * Filter by a single bitrate value.
+     */
+    static bitrate(key, value) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_BitrateFilterKey(key);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.bitrate);
+            }
+            throw error;
+        }
+        const bps = value.toBps();
+        validateBitrateFilterValue(bps, key);
+        return new ManifestFilter(`${key}:${bps}`);
+    }
+    /**
+     * Filter by a bitrate range (inclusive).
+     */
+    static bitrateRange(key, start, end) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_BitrateFilterKey(key);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.bitrateRange);
+            }
+            throw error;
+        }
+        const startBps = start.toBps();
+        const endBps = end.toBps();
+        validateBitrateFilterValue(startBps, key);
+        validateBitrateFilterValue(endBps, key);
+        return new ManifestFilter(`${key}:${startBps}-${endBps}`);
+    }
+    /**
+     * Specify a single numeric filter value.
+     */
+    static numeric(key, value) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_NumericFilterKey(key);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.numeric);
+            }
+            throw error;
+        }
+        validateNumericFilterValue(value, key);
+        return new ManifestFilter(`${key}:${value}`);
+    }
+    /**
+     * Specify multiple numeric filter values.
+     */
+    static numericList(key, values) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_NumericFilterKey(key);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.numericList);
+            }
+            throw error;
+        }
+        values.forEach(v => validateNumericFilterValue(v, key));
+        return new ManifestFilter(`${key}:${values.join(',')}`);
+    }
+    /**
+     * Specify a numeric filter range (inclusive).
+     */
+    static numericRange(key, start, end) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_NumericFilterKey(key);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.numericRange);
+            }
+            throw error;
+        }
+        validateNumericFilterValue(start, key);
+        validateNumericFilterValue(end, key);
+        return new ManifestFilter(`${key}:${start}-${end}`);
+    }
+    /**
+     * Specify a free-form text filter value (for language keys).
+     */
+    static text(key, value) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_TextFilterKey(key);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.text);
+            }
+            throw error;
+        }
+        return new ManifestFilter(`${key}:${value}`);
+    }
+    /**
+     * Specify multiple free-form text filter values (for language keys).
+     */
+    static textList(key, values) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_TextFilterKey(key);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.textList);
+            }
+            throw error;
+        }
+        return new ManifestFilter(`${key}:${values.join(',')}`);
+    }
+    /**
+     * Filter by a single audio codec.
+     */
+    static audioCodec(value) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_AudioCodec(value);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.audioCodec);
+            }
+            throw error;
+        }
+        return new ManifestFilter(`audio_codec:${value}`);
+    }
+    /**
+     * Filter by multiple audio codecs.
+     */
+    static audioCodecList(values) {
+        return new ManifestFilter(`audio_codec:${values.join(',')}`);
+    }
+    /**
+     * Filter by a single video codec.
+     */
+    static videoCodec(value) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_VideoCodec(value);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.videoCodec);
+            }
+            throw error;
+        }
+        return new ManifestFilter(`video_codec:${value}`);
+    }
+    /**
+     * Filter by multiple video codecs.
+     */
+    static videoCodecList(values) {
+        return new ManifestFilter(`video_codec:${values.join(',')}`);
+    }
+    /**
+     * Filter by a single video dynamic range.
+     */
+    static videoDynamicRange(value) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_VideoDynamicRange(value);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.videoDynamicRange);
+            }
+            throw error;
+        }
+        return new ManifestFilter(`video_dynamic_range:${value}`);
+    }
+    /**
+     * Filter by multiple video dynamic ranges.
+     */
+    static videoDynamicRangeList(values) {
+        return new ManifestFilter(`video_dynamic_range:${values.join(',')}`);
+    }
+    /**
+     * Filter by a single trickplay type.
+     */
+    static trickplayType(value) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_TrickplayType(value);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.trickplayType);
+            }
+            throw error;
+        }
+        return new ManifestFilter(`trickplay_type:${value}`);
+    }
+    /**
+     * Filter by multiple trickplay types.
+     */
+    static trickplayTypeList(values) {
+        return new ManifestFilter(`trickplay_type:${values.join(',')}`);
+    }
+    /**
+     * Filter by a combination of numeric ranges and individual values.
+     *
+     * Use this for advanced patterns like `video_height:240-360,720-1080,1440`.
+     *
+     * @example
+     * ManifestFilter.numericCombo(NumericFilterKey.VIDEO_HEIGHT, [
+     *   NumericExpression.range(240, 360),
+     *   NumericExpression.range(720, 1080),
+     *   NumericExpression.value(1440),
+     * ])
+     */
+    static numericCombo(key, expressions) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_NumericFilterKey(key);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.numericCombo);
+            }
+            throw error;
+        }
+        expressions.forEach(expr => expr._values.forEach(v => validateNumericFilterValue(v, key)));
+        return new ManifestFilter(`${key}:${expressions.map(e => e._expression).join(',')}`);
+    }
+    /**
+     * Filter by a combination of bitrate ranges and individual values.
+     *
+     * @example
+     * ManifestFilter.bitrateCombo(BitrateFilterKey.VIDEO_BITRATE, [
+     *   BitrateExpression.range(Bitrate.mbps(1), Bitrate.mbps(3)),
+     *   BitrateExpression.value(Bitrate.mbps(5)),
+     * ])
+     */
+    static bitrateCombo(key, expressions) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_BitrateFilterKey(key);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.bitrateCombo);
+            }
+            throw error;
+        }
+        expressions.forEach(expr => expr._values.forEach(v => validateBitrateFilterValue(v, key)));
+        return new ManifestFilter(`${key}:${expressions.map(e => e._expression).join(',')}`);
+    }
+    /**
+     * Specify a custom manifest filter string.
+     */
+    static custom(custom) {
+        return new ManifestFilter(custom);
+    }
+    /**
+     * @param filterString Normalised manifest filter string
+     */
+    constructor(filterString) {
+        this.filterString = filterString;
+    }
+}
+exports.ManifestFilter = ManifestFilter;
+/**
+ * Manifest to add to Origin Endpoint
+ */
+class Manifest {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediapackagev2-alpha.Manifest", version: "2.247.0-alpha.0" };
+    /**
+     * Specify a manifest configuration for Low Latency HLS.
+     *
+     * **Note:** Low Latency HLS manifests require TS or CMAF container type.
+     * Use with `Segment.ts()` or `Segment.cmaf()`.
+     */
+    static lowLatencyHLS(manifest) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_LowLatencyHlsManifestConfiguration(manifest);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.lowLatencyHLS);
+            }
+            throw error;
+        }
+        return new LowLatencyHlsManifest(manifest);
+    }
+    /**
+     * Specify a manifest configuration for HLS.
+     *
+     * **Note:** HLS manifests require TS or CMAF container type.
+     * Use with `Segment.ts()` or `Segment.cmaf()`.
+     */
+    static hls(manifest) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_HlsManifestConfiguration(manifest);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.hls);
+            }
+            throw error;
+        }
+        return new HlsManifest(manifest);
+    }
+    /**
+     * Specify a manifest configuration for DASH.
+     *
+     * **Note:** DASH manifests require CMAF container type.
+     * Use with `Segment.cmaf()`.
+     */
+    static dash(manifest) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_DashManifestConfiguration(manifest);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.dash);
+            }
+            throw error;
+        }
+        return new DashManifest(manifest);
+    }
+    /**
+     * Specify a manifest configuration for MSS.
+     *
+     * **Note:** MSS manifests require ISM container type.
+     * Use with `Segment.ism()`.
+     */
+    static mss(manifest) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_MssManifestConfiguration(manifest);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.mss);
+            }
+            throw error;
+        }
+        return new MssManifest(manifest);
+    }
+}
+exports.Manifest = Manifest;
+/**
+ * Validate a numeric filter value is an integer within the accepted range for its key.
+ * VIDEO_FRAMERATE is excluded — it uses `validateFramerateValue` instead.
+ * @internal
+ */
+function validateIntegerFilterValue(value, key, min, max) {
+    if (!Number.isInteger(value)) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `NumericFilterMustBeInteger`, `Numeric filter value for '${key}' must be an integer, got ${value}`);
+    }
+    if (value < min || value > max) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `NumericFilterOutOfRange`, `Numeric filter value for '${key}' must be between ${min} and ${max}, got ${value}`);
+    }
+}
+/**
+ * Validate a video framerate filter value (1–999.999, up to 3 decimal places).
+ * @internal
+ */
+function validateFramerateValue(value) {
+    if (value < 1 || value > 999.999) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `NumericFilterOutOfRange`, `Numeric filter value for 'video_framerate' must be between 1 and 999.999, got ${value}`);
+    }
+    const decimalPart = value.toString().split('.')[1];
+    if (decimalPart && decimalPart.length > 3) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `NumericFilterMaxDecimalPlaces`, `Numeric filter value for 'video_framerate' allows up to 3 decimal places, got ${value}`);
+    }
+}
+/**
+ * Route numeric validation to the correct helper based on key.
+ * @internal
+ */
+function validateNumericFilterValue(value, key) {
+    switch (key) {
+        case NumericFilterKey.AUDIO_CHANNELS:
+            return validateIntegerFilterValue(value, key, 1, 32_767);
+        case NumericFilterKey.AUDIO_SAMPLE_RATE:
+            return validateIntegerFilterValue(value, key, 0, 2_147_483_647);
+        case NumericFilterKey.TRICKPLAY_HEIGHT:
+            return validateIntegerFilterValue(value, key, 1, 2_147_483_647);
+        case NumericFilterKey.VIDEO_FRAMERATE:
+            return validateFramerateValue(value);
+        case NumericFilterKey.VIDEO_HEIGHT:
+            return validateIntegerFilterValue(value, key, 1, 32_767);
+    }
+}
+/**
+ * Validate a bitrate filter value is an integer within the accepted range.
+ * @internal
+ */
+function validateBitrateFilterValue(bps, key) {
+    if (!Number.isInteger(bps)) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `BitrateFilterMustBeInteger`, `Bitrate filter value for '${key}' must resolve to a whole number of bits per second, got ${bps}`);
+    }
+    if (bps < 0 || bps > 2_147_483_647) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `BitrateFilterOutOfRange`, `Bitrate filter value for '${key}' must be between 0 and 2147483647, got ${bps}`);
+    }
+}
+/**
+ * Validates common manifest configuration properties
+ */
+function validateManifestConfiguration(config) {
+    if (config.manifestWindow && config.manifestWindow.toSeconds() < 30) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `ManifestWindowMinimum`, 'Manifest Window has a minimum value of 30 seconds');
+    }
+}
+/**
+ * Validate and modify filter configuration
+ * @internal
+ */
+function validateFilterConfiguration(filterConfig) {
+    if (!filterConfig)
+        return undefined;
+    if (filterConfig.clipStartTime && (filterConfig.start || filterConfig.end)) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `ClipStartTimeConflict`, 'You cannot specify both ClipStartTime with Start or End in a FilterConfiguration.');
+    }
+    if (filterConfig.timeDelay && (filterConfig.timeDelay.toSeconds() < 0 || filterConfig.timeDelay.toSeconds() > 1209600)) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `TimeDelayRange`, 'Time Delay setting should be defined between 0-1209600 seconds.');
+    }
+    if (filterConfig.start && filterConfig.end && (filterConfig.end <= filterConfig.start)) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `EndBeforeStart`, 'The End parameter needs to be after the Start parameter in a FilterConfiguration.');
+    }
+    const manifestFilter = filterConfig.manifestFilter ? filterConfig.manifestFilter.map(filter => filter.filterString).join(';') : undefined;
+    if (manifestFilter != undefined && (manifestFilter.length < 1 || manifestFilter.length > 1024)) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `ManifestFilterLength`, 'Manifest filter needs to be between 1-1024 characters in length.');
+    }
+    if (filterConfig.manifestFilter && filterConfig.manifestFilter.length > 1) {
+        const keys = filterConfig.manifestFilter.map(f => f.filterString.split(':')[0]);
+        keys.forEach((key, i) => {
+            if (keys.indexOf(key) !== i) {
+                throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `DuplicateManifestFilterKey`, `Duplicate manifest filter key '${key}'. Use a single filter with comma-separated values instead (e.g. ManifestFilter.numericList() or ManifestFilter.custom()).`);
+            }
+        });
+    }
+    return {
+        manifestFilter,
+        drmSettings: filterConfig.drmSettings ? filterConfig.drmSettings.filter((v, i, a) => a.indexOf(v) === i).join(';') : undefined,
+        clipStartTime: filterConfig.clipStartTime ? (0, shared_helpers_1.convertDateToString)(filterConfig.clipStartTime) : undefined,
+        start: filterConfig.start ? (0, shared_helpers_1.convertDateToString)(filterConfig.start) : undefined,
+        end: filterConfig.end ? (0, shared_helpers_1.convertDateToString)(filterConfig.end) : undefined,
+        timeDelaySeconds: filterConfig.timeDelay?.toSeconds(),
+    };
+}
+/**
+ * Validate startTag configuration
+ * @internal
+ */
+function validateStartTag(startTag, manifestWindow, segmentDuration) {
+    const timeOffset = startTag.timeOffset;
+    // Get segment duration (default is 6 seconds if not specified)
+    const segmentDurationSec = segmentDuration?.toSeconds() ?? 6;
+    // Get manifest duration (default is 60 seconds if not specified)
+    const manifestDurationSec = manifestWindow?.toSeconds() ?? 60;
+    // Validate positive offset (from start)
+    if (timeOffset > 0) {
+        const maxPositiveOffset = manifestDurationSec - (3 * segmentDurationSec);
+        if (timeOffset >= maxPositiveOffset) {
+            throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `StartTagPositiveOffsetExceeded`, `StartTag timeOffset (${timeOffset}s) must be less than manifest duration (${manifestDurationSec}s) minus 3 times segment duration (${segmentDurationSec}s). Maximum allowed: ${maxPositiveOffset}s`);
+        }
+    }
+    // Validate negative offset (from live edge)
+    if (timeOffset < 0) {
+        const absOffset = Math.abs(timeOffset);
+        const minNegativeOffset = 3 * segmentDurationSec;
+        if (absOffset <= minNegativeOffset) {
+            throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `StartTagNegativeOffsetTooSmall`, `StartTag timeOffset (${timeOffset}s) absolute value must be greater than 3 times segment duration (${segmentDurationSec}s). Minimum allowed: -${minNegativeOffset + 0.01}s`);
+        }
+        if (absOffset >= manifestDurationSec) {
+            throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `StartTagNegativeOffsetExceedsManifest`, `StartTag timeOffset (${timeOffset}s) absolute value must be less than manifest duration (${manifestDurationSec}s)`);
+        }
+    }
+}
+/**
+ * Build HLS manifest configuration
+ * @internal
+ */
+function buildHlsManifestConfiguration(config, segmentDuration) {
+    if (config.startTag) {
+        validateStartTag(config.startTag, config.manifestWindow, segmentDuration);
+    }
+    return {
+        manifestName: config.manifestName,
+        childManifestName: config.childManifestName,
+        manifestWindowSeconds: config.manifestWindow?.toSeconds(),
+        programDateTimeIntervalSeconds: config.programDateTimeInterval?.toSeconds(),
+        scteHls: config.scteAdMarkerHls ? { adMarkerHls: config.scteAdMarkerHls } : undefined,
+        startTag: config.startTag,
+        urlEncodeChildManifest: config.urlEncodeChildManifest,
+        filterConfiguration: validateFilterConfiguration(config.filterConfiguration),
+    };
+}
+/**
+ * Build DASH manifest configuration
+ * @internal
+ */
+function buildDashManifestConfiguration(config, segment) {
+    if (config.minBufferTime && (config.minBufferTime.toSeconds() < 1 || config.minBufferTime.toSeconds() > 3600)) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `MinBufferTimeRange`, 'Min buffer time has a range from 1 sec. to 3600 sec.');
+    }
+    if (config.minUpdatePeriod && (config.minUpdatePeriod.toSeconds() < 1 || config.minUpdatePeriod.toSeconds() > 3600)) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `MinUpdatePeriodRange`, 'Min update period option has a range from 1 sec. to 3600 sec.');
+    }
+    if (config.scteDashAdMarker && (!segment?.scteFilter || segment.scteFilter?.length === 0)) {
+        throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `ScteFilterRequired`, 'SCTE Filter must be configured with DashAdMarker Configuration');
+    }
+    return {
+        manifestName: config.manifestName,
+        baseUrls: config.baseUrls,
+        compactness: config.compactness,
+        drmSignaling: config.drmSignalling,
+        dvbSettings: config.dvbSettings,
+        profiles: config.profiles,
+        programInformation: config.programInformation,
+        subtitleConfiguration: config.subtitleConfiguration,
+        manifestWindowSeconds: config.manifestWindow?.toSeconds(),
+        minBufferTimeSeconds: config.minBufferTime?.toSeconds(),
+        minUpdatePeriodSeconds: config.minUpdatePeriod?.toSeconds(),
+        suggestedPresentationDelaySeconds: config.suggestedPresentationDelay?.toSeconds(),
+        segmentTemplateFormat: config.segmentTemplateFormat,
+        periodTriggers: config.periodTriggers,
+        scteDash: segment?.scteFilter ? {
+            adMarkerDash: config.scteDashAdMarker,
+        } : undefined,
+        utcTiming: config.utcTimingMode || config.utcTimingSource ? {
+            timingMode: config.utcTimingMode,
+            timingSource: config.utcTimingSource,
+        } : undefined,
+        filterConfiguration: validateFilterConfiguration(config.filterConfiguration),
+    };
+}
+/**
+ * Build MSS manifest configuration
+ * @internal
+ */
+function buildMssManifestConfiguration(config) {
+    return {
+        manifestName: config.manifestName,
+        manifestLayout: config.manifestLayout,
+        manifestWindowSeconds: config.manifestWindow?.toSeconds(),
+        filterConfiguration: validateFilterConfiguration(config.filterConfiguration),
+    };
+}
+/**
+ * HLS Manifest implementation
+ */
+class HlsManifest extends Manifest {
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    _bind(context) {
+        validateManifestConfiguration(this.config);
+        context.hlsManifests.push(buildHlsManifestConfiguration(this.config, context.segment?.segmentDuration));
+    }
+}
+/**
+ * Low Latency HLS Manifest implementation
+ */
+class LowLatencyHlsManifest extends Manifest {
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    _bind(context) {
+        validateManifestConfiguration(this.config);
+        context.llHlsManifests.push(buildHlsManifestConfiguration(this.config, context.segment?.segmentDuration));
+    }
+}
+/**
+ * DASH Manifest implementation
+ */
+class DashManifest extends Manifest {
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    _bind(context) {
+        validateManifestConfiguration(this.config);
+        if (this.config.utcTimingMode === DashUtcTimingMode.UTC_DIRECT && this.config.utcTimingSource) {
+            throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `UtcDirectTimingSource`, 'UTC Direct configured with a timing source, ensure timing source is undefined to use UTC Direct.');
+        }
+        context.dashManifests.push(buildDashManifestConfiguration(this.config, context.segment));
+    }
+}
+/**
+ * MSS Manifest implementation
+ */
+class MssManifest extends Manifest {
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    _bind(context) {
+        validateManifestConfiguration(this.config);
+        context.mssManifests.push(buildMssManifestConfiguration(this.config));
+    }
+}
+/**
+ * The type of container to attach to this origin endpoint.
+ * A container type is a file format that encapsulates one or more media streams, such as audio and video, into a single file. You can't change the container type after you create the endpoint.
+ */
+var ContainerType;
+(function (ContainerType) {
+    /**
+     * TS Container Type
+     */
+    ContainerType["TS"] = "TS";
+    /**
+     * CMAF Container Type
+     */
+    ContainerType["CMAF"] = "CMAF";
+    /**
+     * ISM Container Type (Microsoft Smooth Streaming)
+     */
+    ContainerType["ISM"] = "ISM";
+})(ContainerType || (exports.ContainerType = ContainerType = {}));
+/**
+ * Encryption methods for CMAF container type.
+ */
+var CmafEncryptionMethod;
+(function (CmafEncryptionMethod) {
+    /**
+     * Common Encryption Scheme (CENC) - compatible with PlayReady, Widevine, and Irdeto DRM systems.
+     */
+    CmafEncryptionMethod["CENC"] = "CENC";
+    /**
+     * Common Encryption Scheme with CBCS mode - compatible with PlayReady, Widevine, and FairPlay DRM systems.
+     */
+    CmafEncryptionMethod["CBCS"] = "CBCS";
+})(CmafEncryptionMethod || (exports.CmafEncryptionMethod = CmafEncryptionMethod = {}));
+/**
+ * Encryption methods for TS container type.
+ */
+var TsEncryptionMethod;
+(function (TsEncryptionMethod) {
+    /**
+     * AES-128 encryption - requires Clear Key AES 128 DRM system.
+     */
+    TsEncryptionMethod["AES_128"] = "AES_128";
+    /**
+     * Sample-level AES encryption - requires FairPlay DRM system.
+     */
+    TsEncryptionMethod["SAMPLE_AES"] = "SAMPLE_AES";
+})(TsEncryptionMethod || (exports.TsEncryptionMethod = TsEncryptionMethod = {}));
+/**
+ * A collection of audio encryption presets.
+ */
+var PresetSpeke20Audio;
+(function (PresetSpeke20Audio) {
+    /**
+     * Use one content key to encrypt all of the audio tracks in your stream.
+     */
+    PresetSpeke20Audio["PRESET_AUDIO_1"] = "PRESET_AUDIO_1";
+    /**
+     * Use one content key to encrypt all of the stereo audio tracks and one content key to encrypt all of the multichannel audio tracks.
+     */
+    PresetSpeke20Audio["PRESET_AUDIO_2"] = "PRESET_AUDIO_2";
+    /**
+     * Use one content key to encrypt all of the stereo audio tracks, one content key to encrypt all of the multichannel audio tracks with 3 to 6 channels,
+     * and one content key to encrypt all of the multichannel audio tracks with more than 6 channels.
+     */
+    PresetSpeke20Audio["PRESET_AUDIO_3"] = "PRESET_AUDIO_3";
+    /**
+     * Use the same content key for all of the audio and video tracks in your stream.
+     */
+    PresetSpeke20Audio["SHARED"] = "SHARED";
+    /**
+     * Don't encrypt any of the audio tracks in your stream.
+     */
+    PresetSpeke20Audio["UNENCRYPTED"] = "UNENCRYPTED";
+})(PresetSpeke20Audio || (exports.PresetSpeke20Audio = PresetSpeke20Audio = {}));
+/**
+ * The SPEKE Version 2.0 preset video associated with the encryption contract configuration of the origin endpoint.
+ *
+ * A collection of video encryption presets.
+ */
+var PresetSpeke20Video;
+(function (PresetSpeke20Video) {
+    /**
+     * Use one content key to encrypt all of the video tracks in your stream.
+     */
+    PresetSpeke20Video["PRESET_VIDEO_1"] = "PRESET_VIDEO_1";
+    /**
+     * Use one content key to encrypt all of the SD video tracks and one content key for all HD and higher resolutions video tracks.
+     */
+    PresetSpeke20Video["PRESET_VIDEO_2"] = "PRESET_VIDEO_2";
+    /**
+     * Use one content key to encrypt all of the SD video tracks, one content key for HD video tracks and one content key for all UHD video tracks.
+     */
+    PresetSpeke20Video["PRESET_VIDEO_3"] = "PRESET_VIDEO_3";
+    /**
+     * Use one content key to encrypt all of the SD video tracks, one content key for HD video tracks,
+     * one content key for all UHD1 video tracks and one content key for all UHD2 video tracks.
+     */
+    PresetSpeke20Video["PRESET_VIDEO_4"] = "PRESET_VIDEO_4";
+    /**
+     * Use one content key to encrypt all of the SD video tracks, one content key for HD1 video tracks, one content key for HD2 video tracks,
+     * one content key for all UHD1 video tracks and one content key for all UHD2 video tracks.
+     */
+    PresetSpeke20Video["PRESET_VIDEO_5"] = "PRESET_VIDEO_5";
+    /**
+     * Use one content key to encrypt all of the SD video tracks, one content key for HD1 video tracks, one content key for HD2 video tracks
+     * and one content key for all UHD video tracks.
+     */
+    PresetSpeke20Video["PRESET_VIDEO_6"] = "PRESET_VIDEO_6";
+    /**
+     * Use one content key to encrypt all of the SD+HD1 video tracks, one content key for HD2 video tracks and one content key for all UHD video tracks.
+     */
+    PresetSpeke20Video["PRESET_VIDEO_7"] = "PRESET_VIDEO_7";
+    /**
+     * Use one content key to encrypt all of the SD+HD1 video tracks, one content key for HD2 video tracks, one content key for all UHD1
+     * video tracks and one content key for all UHD2 video tracks.
+     */
+    PresetSpeke20Video["PRESET_VIDEO_8"] = "PRESET_VIDEO_8";
+    /**
+     * Use the same content key for all of the video and audio tracks in your stream.
+     */
+    PresetSpeke20Video["SHARED"] = "SHARED";
+    /**
+     * Don't encrypt any of the video tracks in your stream.
+     */
+    PresetSpeke20Video["UNENCRYPTED"] = "UNENCRYPTED";
+})(PresetSpeke20Video || (exports.PresetSpeke20Video = PresetSpeke20Video = {}));
+/**
+ * Endpoint error configuration options.
+ */
+var EndpointErrorConfiguration;
+(function (EndpointErrorConfiguration) {
+    /**
+     * The manifest stalled and there are no new segments or parts.
+     */
+    EndpointErrorConfiguration["STALE_MANIFEST"] = "STALE_MANIFEST";
+    /**
+     * There is a gap in the manifest.
+     */
+    EndpointErrorConfiguration["INCOMPLETE_MANIFEST"] = "INCOMPLETE_MANIFEST";
+    /**
+     * Key rotation is enabled but we're unable to fetch the key for the current key period.
+     */
+    EndpointErrorConfiguration["MISSING_DRM_KEY"] = "MISSING_DRM_KEY";
+    /**
+     * The segments which contain slate content are considered to be missing content.
+     */
+    EndpointErrorConfiguration["SLATE_INPUT"] = "SLATE_INPUT";
+})(EndpointErrorConfiguration || (exports.EndpointErrorConfiguration = EndpointErrorConfiguration = {}));
+/**
+ * SCTE-35 message type options available.
+ */
+var ScteMessageType;
+(function (ScteMessageType) {
+    /**
+     * Option for SPLICE_INSERT.
+     */
+    ScteMessageType["SPLICE_INSERT"] = "SPLICE_INSERT";
+    /**
+     * Option for BREAK.
+     */
+    ScteMessageType["BREAK"] = "BREAK";
+    /**
+     * Option for PROVIDER_ADVERTISEMENT.
+     */
+    ScteMessageType["PROVIDER_ADVERTISEMENT"] = "PROVIDER_ADVERTISEMENT";
+    /**
+     * Option for DISTRIBUTOR_ADVERTISEMENT.
+     */
+    ScteMessageType["DISTRIBUTOR_ADVERTISEMENT"] = "DISTRIBUTOR_ADVERTISEMENT";
+    /**
+     * Option for PROVIDER_PLACEMENT_OPPORTUNITY.
+     */
+    ScteMessageType["PROVIDER_PLACEMENT_OPPORTUNITY"] = "PROVIDER_PLACEMENT_OPPORTUNITY";
+    /**
+     * Option for DISTRIBUTOR_PLACEMENT_OPPORTUNITY.
+     */
+    ScteMessageType["DISTRIBUTOR_PLACEMENT_OPPORTUNITY"] = "DISTRIBUTOR_PLACEMENT_OPPORTUNITY";
+    /**
+     * Option for PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY.
+     */
+    ScteMessageType["PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY"] = "PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY";
+    /**
+     * Option for DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY.
+     */
+    ScteMessageType["DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY"] = "DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY";
+    /**
+     * Option for PROGRAM.
+     */
+    ScteMessageType["PROGRAM"] = "PROGRAM";
+})(ScteMessageType || (exports.ScteMessageType = ScteMessageType = {}));
+/**
+ * Controls whether SCTE-35 messages are included in segment files.
+ */
+var ScteInSegments;
+(function (ScteInSegments) {
+    /**
+     * SCTE-35 messages are not included in segments.
+     */
+    ScteInSegments["NONE"] = "NONE";
+    /**
+     * SCTE-35 messages are embedded in segment data.
+     *
+     * For DASH manifests, when set to ALL, an InbandEventStream tag signals
+     * that SCTE messages are present in segments.
+     */
+    ScteInSegments["ALL"] = "ALL";
+})(ScteInSegments || (exports.ScteInSegments = ScteInSegments = {}));
+/**
+ * DRM settings keys for manifest filter configuration.
+ */
+var DrmSettingsKey;
+(function (DrmSettingsKey) {
+    /**
+     * Exclude EXT-X-SESSION-KEY tags from HLS and LL-HLS multivariant playlists.
+     *
+     * This can improve compatibility with legacy HLS clients that have issues
+     * processing session keys, or provide more granular access control when
+     * using manifest filtering.
+     */
+    DrmSettingsKey["EXCLUDE_SESSION_KEYS"] = "exclude_session_keys";
+})(DrmSettingsKey || (exports.DrmSettingsKey = DrmSettingsKey = {}));
+/**
+ * Helper class for creating EXT-X-START tags in HLS playlists.
+ *
+ * The EXT-X-START tag indicates a preferred point at which to start playing a playlist.
+ */
+class StartTag {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediapackagev2-alpha.StartTag", version: "2.247.0-alpha.0" };
+    /**
+     * Create a start tag with a time offset.
+     *
+     * @param timeOffset The time offset in seconds. Can be positive (forward from start) or negative (back from live edge).
+     *   - If positive: must be less than (manifest duration - 3 × segment duration)
+     *   - If negative: absolute value must be greater than (3 × segment duration) and less than manifest duration
+     * @param options Additional options
+     */
+    static of(timeOffset, options) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_StartTagOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.of);
+            }
+            throw error;
+        }
+        return {
+            timeOffset,
+            precise: options && options.precise !== undefined ? options.precise : undefined,
+        };
+    }
+    /**
+     * Create a start tag with precise positioning enabled (PRECISE=YES).
+     *
+     * @param timeOffset The time offset in seconds (positive or negative)
+     */
+    static withPrecise(timeOffset) {
+        return {
+            timeOffset,
+            precise: true,
+        };
+    }
+}
+exports.StartTag = StartTag;
+/**
+ * Choose how ad markers are included in the packaged content.
+ */
+var AdMarkerDash;
+(function (AdMarkerDash) {
+    /**
+     * Option for BINARY - The SCTE-35 marker is expressed as a hex-string (Base64 string) rather than full XML.
+     */
+    AdMarkerDash["BINARY"] = "BINARY";
+    /**
+     * Option for XML - The SCTE marker is expressed fully in XML.
+     */
+    AdMarkerDash["XML"] = "XML";
+})(AdMarkerDash || (exports.AdMarkerDash = AdMarkerDash = {}));
+/**
+ * Choose how SCTE-35 ad markers are included in HLS and LL-HLS manifests.
+ */
+var AdMarkerHls;
+(function (AdMarkerHls) {
+    /**
+     * Insert EXT-X-DATERANGE tags to signal ad content.
+     */
+    AdMarkerHls["DATERANGE"] = "DATERANGE";
+    /**
+     * Insert enhanced SCTE-35 tags for ad content.
+     */
+    AdMarkerHls["SCTE35_ENHANCED"] = "SCTE35_ENHANCED";
+})(AdMarkerHls || (exports.AdMarkerHls = AdMarkerHls = {}));
+/**
+ * The type of variable that MediaPackage uses in the media attribute of the SegmentTemplate tag.
+ */
+var SegmentTemplateFormat;
+(function (SegmentTemplateFormat) {
+    /**
+     * Option for number with timeline.
+     */
+    SegmentTemplateFormat["NUMBER_WITH_TIMELINE"] = "NUMBER_WITH_TIMELINE";
+})(SegmentTemplateFormat || (exports.SegmentTemplateFormat = SegmentTemplateFormat = {}));
+/**
+ * The UTC timing mode for DASH.
+ */
+var DashUtcTimingMode;
+(function (DashUtcTimingMode) {
+    /**
+     * Option for HTTP_HEAD.
+     */
+    DashUtcTimingMode["HTTP_HEAD"] = "HTTP_HEAD";
+    /**
+     * Option for HTTP_ISO.
+     */
+    DashUtcTimingMode["HTTP_ISO"] = "HTTP_ISO";
+    /**
+     * Option for HTTP_XSDATE.
+     */
+    DashUtcTimingMode["HTTP_XSDATE"] = "HTTP_XSDATE";
+    /**
+     * Option for UTC_DIRECT.
+     */
+    DashUtcTimingMode["UTC_DIRECT"] = "UTC_DIRECT";
+})(DashUtcTimingMode || (exports.DashUtcTimingMode = DashUtcTimingMode = {}));
+/**
+ * Options for triggers which cause AWS Elemental MediaPackage to create media presentation description (MPD) periods in the output manifest.
+ */
+var DashPeriodTriggers;
+(function (DashPeriodTriggers) {
+    /**
+     * Option for AVAILS.
+     */
+    DashPeriodTriggers["AVAILS"] = "AVAILS";
+    /**
+     * Option for DRM_KEY_ROTATION.
+     */
+    DashPeriodTriggers["DRM_KEY_ROTATION"] = "DRM_KEY_ROTATION";
+    /**
+     * Option for SOURCE_CHANGES.
+     */
+    DashPeriodTriggers["SOURCE_CHANGES"] = "SOURCE_CHANGES";
+    /**
+     * Option for SOURCE_DISRUPTIONS.
+     */
+    DashPeriodTriggers["SOURCE_DISRUPTIONS"] = "SOURCE_DISRUPTIONS";
+    /**
+     * Option for NONE.
+     */
+    DashPeriodTriggers["NONE"] = "NONE";
+})(DashPeriodTriggers || (exports.DashPeriodTriggers = DashPeriodTriggers = {}));
+/**
+ * DRM signaling determines the way DASH manifest signals the DRM content.
+ */
+var DrmSignalling;
+(function (DrmSignalling) {
+    /**
+     * Option for INDIVIDUAL.
+     */
+    DrmSignalling["INDIVIDUAL"] = "INDIVIDUAL";
+    /**
+     * Option for REFERENCED.
+     */
+    DrmSignalling["REFERENCED"] = "REFERENCED";
+})(DrmSignalling || (exports.DrmSignalling = DrmSignalling = {}));
+/**
+ * STANDARD indicates a default manifest, which is compacted. NONE indicates a full manifest.
+ */
+var DashManifestCompactness;
+(function (DashManifestCompactness) {
+    /**
+     * STANDARD
+     */
+    DashManifestCompactness["STANDARD"] = "STANDARD";
+    /**
+     * NONE
+     */
+    DashManifestCompactness["NONE"] = "NONE";
+})(DashManifestCompactness || (exports.DashManifestCompactness = DashManifestCompactness = {}));
+/**
+ * Options for TTML Profile
+ */
+var TtmlProfile;
+(function (TtmlProfile) {
+    /**
+     * IMSC_1
+     */
+    TtmlProfile["IMSC_1"] = "IMSC_1";
+    /**
+     * EBU_TT_D_101
+     */
+    TtmlProfile["EBU_TT_D_101"] = "EBU_TT_D_101";
+})(TtmlProfile || (exports.TtmlProfile = TtmlProfile = {}));
+/**
+ * The layout of the MSS manifest.
+ */
+var MssManifestLayout;
+(function (MssManifestLayout) {
+    /**
+     * Full manifest layout.
+     */
+    MssManifestLayout["FULL"] = "FULL";
+    /**
+     * Compact manifest layout.
+     */
+    MssManifestLayout["COMPACT"] = "COMPACT";
+})(MssManifestLayout || (exports.MssManifestLayout = MssManifestLayout = {}));
+/**
+ * DRM systems available for CMAF encryption.
+ *
+ * CENC supports PlayReady, Widevine, and Irdeto.
+ * CBCS supports PlayReady, Widevine, and FairPlay.
+ */
+var CmafDrmSystem;
+(function (CmafDrmSystem) {
+    /**
+     * FairPlay DRM - used with CBCS encryption.
+     */
+    CmafDrmSystem["FAIRPLAY"] = "FAIRPLAY";
+    /**
+     * PlayReady DRM - used with CENC and CBCS encryption.
+     */
+    CmafDrmSystem["PLAYREADY"] = "PLAYREADY";
+    /**
+     * Widevine DRM - used with CENC and CBCS encryption.
+     */
+    CmafDrmSystem["WIDEVINE"] = "WIDEVINE";
+    /**
+     * Irdeto DRM - used with CENC encryption.
+     */
+    CmafDrmSystem["IRDETO"] = "IRDETO";
+})(CmafDrmSystem || (exports.CmafDrmSystem = CmafDrmSystem = {}));
+/**
+ * DRM systems available for TS encryption.
+ *
+ * SAMPLE_AES uses FairPlay, AES_128 uses Clear Key AES 128.
+ */
+var TsDrmSystem;
+(function (TsDrmSystem) {
+    /**
+     * FairPlay DRM - used with SAMPLE_AES encryption.
+     */
+    TsDrmSystem["FAIRPLAY"] = "FAIRPLAY";
+    /**
+     * Clear Key AES 128 - used with AES_128 encryption.
+     */
+    TsDrmSystem["CLEAR_KEY_AES_128"] = "CLEAR_KEY_AES_128";
+})(TsDrmSystem || (exports.TsDrmSystem = TsDrmSystem = {}));
+/**
+ * DRM systems available for ISM encryption.
+ *
+ * ISM only supports PlayReady with CENC.
+ */
+var IsmDrmSystem;
+(function (IsmDrmSystem) {
+    /**
+     * PlayReady DRM.
+     */
+    IsmDrmSystem["PLAYREADY"] = "PLAYREADY";
+})(IsmDrmSystem || (exports.IsmDrmSystem = IsmDrmSystem = {}));
+/**
+ * Base class for encryption configurations.
+ *
+ * Use `CmafEncryption.speke()`, `TsEncryption.speke()`, or `IsmEncryption.speke()` to create instances.
+ */
+class EncryptionConfiguration {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediapackagev2-alpha.EncryptionConfiguration", version: "2.247.0-alpha.0" };
+}
+exports.EncryptionConfiguration = EncryptionConfiguration;
+/**
+ * Encryption configuration for CMAF segments.
+ *
+ * Use `CmafEncryption.speke()` to create an instance.
+ */
+class CmafEncryption extends EncryptionConfiguration {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediapackagev2-alpha.CmafEncryption", version: "2.247.0-alpha.0" };
+    /**
+     * Create a SPEKE-based encryption configuration for CMAF segments.
+     */
+    static speke(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_CmafSpekeEncryptionProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.speke);
+            }
+            throw error;
+        }
+        if (!props.url.startsWith('https://')) {
+            throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `SpekeUrlHttpsRequired`, 'SPEKE key provider URL must use HTTPS.');
+        }
+        if (props.method === CmafEncryptionMethod.CENC && props.drmSystems.includes(CmafDrmSystem.FAIRPLAY)) {
+            throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `CencFairPlayIncompatible`, 'CENC encryption method does not support FairPlay. Use CBCS for FairPlay.');
+        }
+        if (props.method === CmafEncryptionMethod.CBCS && props.drmSystems.includes(CmafDrmSystem.IRDETO)) {
+            throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `CbcsIrdetoIncompatible`, 'CBCS encryption method does not support Irdeto. Use CENC for Irdeto.');
+        }
+        return new CmafEncryption(props);
+    }
+    config;
+    constructor(props) {
+        super();
+        this.config = props;
+    }
+    /** @internal */
+    _bind(scope) {
+        const p = this.config;
+        if (p.constantInitializationVector && p.constantInitializationVector.length !== 32) {
+            throw new core_1.ValidationError((0, helpers_internal_1.lit) `ConstantInitVectorLength`, 'Constant Initialization Vector needs to be 32 characters in length.', scope);
+        }
+        if (p.keyRotationInterval && (p.keyRotationInterval.toSeconds() < 300 || p.keyRotationInterval.toSeconds() > 31536000)) {
+            throw new core_1.ValidationError((0, helpers_internal_1.lit) `KeyRotationIntervalRange`, 'Key Rotation Interval needs to be between 300-31536000 seconds.', scope);
+        }
+        return {
+            cmafExcludeSegmentDrmMetadata: p.excludeSegmentDrmMetadata,
+            constantInitializationVector: p.constantInitializationVector,
+            keyRotationIntervalSeconds: p.keyRotationInterval?.toSeconds(),
+            encryptionMethod: { cmafEncryptionMethod: p.method },
+            spekeKeyProvider: {
+                certificateArn: p.certificate?.certificateArn,
+                drmSystems: p.drmSystems,
+                encryptionContractConfiguration: {
+                    presetSpeke20Audio: p.audioPreset ?? PresetSpeke20Audio.PRESET_AUDIO_1,
+                    presetSpeke20Video: p.videoPreset ?? PresetSpeke20Video.PRESET_VIDEO_1,
+                },
+                url: p.url,
+                resourceId: p.resourceId,
+                roleArn: p.role.roleArn,
+            },
+        };
+    }
+    /** @internal */
+    _getRole() { return this.config.role; }
+    /** @internal */
+    _getCertificate() { return this.config.certificate; }
+}
+exports.CmafEncryption = CmafEncryption;
+/**
+ * Encryption configuration for TS segments.
+ *
+ * Use `TsEncryption.speke()` to create an instance.
+ */
+class TsEncryption extends EncryptionConfiguration {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediapackagev2-alpha.TsEncryption", version: "2.247.0-alpha.0" };
+    /**
+     * Create a SPEKE-based encryption configuration for TS segments.
+     */
+    static speke(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_TsSpekeEncryptionProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.speke);
+            }
+            throw error;
+        }
+        if (!props.url.startsWith('https://')) {
+            throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `SpekeUrlHttpsRequired`, 'SPEKE key provider URL must use HTTPS.');
+        }
+        return new TsEncryption(props);
+    }
+    config;
+    constructor(props) {
+        super();
+        this.config = props;
+    }
+    /** @internal */
+    _bind(scope) {
+        const p = this.config;
+        const defaultDrm = p.method === TsEncryptionMethod.SAMPLE_AES
+            ? [TsDrmSystem.FAIRPLAY] : [TsDrmSystem.CLEAR_KEY_AES_128];
+        if (p.constantInitializationVector && p.constantInitializationVector.length !== 32) {
+            throw new core_1.ValidationError((0, helpers_internal_1.lit) `ConstantInitVectorLength`, 'Constant Initialization Vector needs to be 32 characters in length.', scope);
+        }
+        if (p.keyRotationInterval && (p.keyRotationInterval.toSeconds() < 300 || p.keyRotationInterval.toSeconds() > 31536000)) {
+            throw new core_1.ValidationError((0, helpers_internal_1.lit) `KeyRotationIntervalRange`, 'Key Rotation Interval needs to be between 300-31536000 seconds.', scope);
+        }
+        return {
+            constantInitializationVector: p.constantInitializationVector,
+            keyRotationIntervalSeconds: p.keyRotationInterval?.toSeconds(),
+            encryptionMethod: { tsEncryptionMethod: p.method },
+            spekeKeyProvider: {
+                certificateArn: p.certificate?.certificateArn,
+                drmSystems: (p.drmSystems ?? defaultDrm).map(d => d.toString()),
+                encryptionContractConfiguration: {
+                    presetSpeke20Audio: p.audioPreset ?? PresetSpeke20Audio.PRESET_AUDIO_1,
+                    presetSpeke20Video: p.videoPreset ?? PresetSpeke20Video.PRESET_VIDEO_1,
+                },
+                url: p.url,
+                resourceId: p.resourceId,
+                roleArn: p.role.roleArn,
+            },
+        };
+    }
+    /** @internal */
+    _getRole() { return this.config.role; }
+    /** @internal */
+    _getCertificate() { return this.config.certificate; }
+}
+exports.TsEncryption = TsEncryption;
+/**
+ * Encryption configuration for ISM (Microsoft Smooth Streaming) segments.
+ *
+ * ISM only supports CENC encryption with PlayReady DRM.
+ * Audio and video presets are always SHARED.
+ *
+ * Use `IsmEncryption.speke()` to create an instance.
+ */
+class IsmEncryption extends EncryptionConfiguration {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediapackagev2-alpha.IsmEncryption", version: "2.247.0-alpha.0" };
+    /**
+     * Create a SPEKE-based encryption configuration for ISM segments.
+     */
+    static speke(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_IsmSpekeEncryptionProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.speke);
+            }
+            throw error;
+        }
+        if (!props.url.startsWith('https://')) {
+            throw new core_1.UnscopedValidationError((0, helpers_internal_1.lit) `SpekeUrlHttpsRequired`, 'SPEKE key provider URL must use HTTPS.');
+        }
+        return new IsmEncryption(props);
+    }
+    config;
+    constructor(props) {
+        super();
+        this.config = props;
+    }
+    /** @internal */
+    _bind(_scope) {
+        const p = this.config;
+        return {
+            encryptionMethod: { ismEncryptionMethod: 'CENC' },
+            spekeKeyProvider: {
+                certificateArn: p.certificate?.certificateArn,
+                drmSystems: (p.drmSystems ?? [IsmDrmSystem.PLAYREADY]).map(d => d.toString()),
+                encryptionContractConfiguration: {
+                    presetSpeke20Audio: PresetSpeke20Audio.SHARED,
+                    presetSpeke20Video: PresetSpeke20Video.SHARED,
+                },
+                url: p.url,
+                resourceId: p.resourceId,
+                roleArn: p.role.roleArn,
+            },
+        };
+    }
+    /** @internal */
+    _getRole() { return this.config.role; }
+    /** @internal */
+    _getCertificate() { return this.config.certificate; }
+}
+exports.IsmEncryption = IsmEncryption;
+/**
+ * Helper class for creating segment configurations.
+ */
+class Segment {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-mediapackagev2-alpha.Segment", version: "2.247.0-alpha.0" };
+    /**
+     * Create a TS (Transport Stream) segment configuration.
+     *
+     * Use this for endpoints with ContainerType.TS.
+     */
+    static ts(props = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_TsSegmentProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.ts);
+            }
+            throw error;
+        }
+        return {
+            containerType: ContainerType.TS,
+            includeIframeOnlyStreams: props.includeIframeOnlyStreams,
+            scteFilter: props.scteFilter,
+            scteInSegments: props.scteInSegments,
+            segmentDuration: props.duration,
+            segmentName: props.name,
+            tsIncludeDvbSubtitles: props.includeDvbSubtitles,
+            tsUseAudioRenditionGroup: props.useAudioRenditionGroup,
+            encryption: props.encryption,
+        };
+    }
+    /**
+     * Create a CMAF segment configuration.
+     *
+     * Use this for endpoints with ContainerType.CMAF.
+     */
+    static cmaf(props = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_CmafSegmentProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.cmaf);
+            }
+            throw error;
+        }
+        return {
+            containerType: ContainerType.CMAF,
+            includeIframeOnlyStreams: props.includeIframeOnlyStreams,
+            scteFilter: props.scteFilter,
+            scteInSegments: props.scteInSegments,
+            segmentDuration: props.duration,
+            segmentName: props.name,
+            encryption: props.encryption,
+        };
+    }
+    /**
+     * Create an ISM (Microsoft Smooth Streaming) segment configuration.
+     *
+     * Use this for endpoints with ContainerType.ISM.
+     */
+    static ism(props = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_IsmSegmentProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.ism);
+            }
+            throw error;
+        }
+        return {
+            containerType: ContainerType.ISM,
+            includeIframeOnlyStreams: props.includeIframeOnlyStreams,
+            segmentDuration: props.duration,
+            segmentName: props.name,
+            encryption: props.encryption,
+        };
+    }
+}
+exports.Segment = Segment;
+class OriginEndpointBase extends aws_cdk_lib_1.Resource {
+    /**
+     * Creates an OriginEndpoint construct that represents an external (imported) Origin Endpoint.
+     */
+    static fromOriginEndpointAttributes(scope, id, attrs) {
+        class Import extends OriginEndpointBase {
+            hlsManifests = [];
+            llHlsManifests = [];
+            dashManifests = [];
+            mssManifests = [];
+            segment;
+            policy = undefined;
+            channelGroupName = attrs.channelGroupName;
+            channelName = attrs.channelName;
+            originEndpointName = attrs.originEndpointName;
+            createdAt = undefined;
+            modifiedAt = undefined;
+            hlsManifestUrls = undefined;
+            lowLatencyHlsManifestUrls = undefined;
+            dashManifestUrls = undefined;
+            mssManifestUrls = undefined;
+            autoCreatePolicy = false;
+            originEndpointArn = aws_cdk_lib_1.Stack.of(this).formatArn({
+                service: 'mediapackagev2',
+                resource: `channelGroup/${attrs.channelGroupName}/channel/${this.channelName}/originEndpoint`,
+                arnFormat: aws_cdk_lib_1.ArnFormat.SLASH_RESOURCE_NAME,
+                resourceName: this.originEndpointName,
+            });
+        }
+        return new Import(scope, id);
+    }
+    /**
+     * A reference to this Origin Endpoint resource.
+     * Required by the auto-generated IOriginEndpointRef interface.
+     */
+    get originEndpointRef() {
+        return {
+            originEndpointArn: this.originEndpointArn,
+        };
+    }
+    /**
+     * CDN authorization configuration to be applied when the policy is created.
+     */
+    cdnAuthConfig;
+    /**
+     * Set CDN auth config. Used by subclass constructors.
+     * @internal
+     */
+    _setCdnAuth(cdnAuth) {
+        if (!this.cdnAuthConfig) {
+            this.cdnAuthConfig = cdnAuth;
+        }
+    }
+    /**
+     * Configure origin endpoint policy.
+     *
+     * You can only add 1 OriginEndpointPolicy to an OriginEndpoint.
+     * If you have already defined one, it will append to the policy already created.
+     *
+     * @param statement - The policy statement to add
+     * @param cdnAuth - Optional CDN authorization configuration. If provided, the policy will be
+     *                  created with CDN authentication enabled using secrets from AWS Secrets Manager.
+     *                  If cdnAuth is provided multiple times, only the first configuration is used.
+     */
+    addToResourcePolicy(statement, cdnAuth) {
+        // Store CDN auth config if provided (only if not already set)
+        if (cdnAuth && !this.cdnAuthConfig) {
+            this.cdnAuthConfig = cdnAuth;
+        }
+        if (!this.policy && this.autoCreatePolicy) {
+            this.policy = new origin_endpoint_policy_1.OriginEndpointPolicy(this, 'Policy', {
+                originEndpoint: this,
+                cdnAuth: this.cdnAuthConfig,
+            });
+        }
+        if (this.policy) {
+            this.policy.document.addStatements(statement);
+            return { statementAdded: true, policyDependable: this.policy };
+        }
+        return { statementAdded: false };
+    }
+    /**
+     * Validate and modify Segment configuration for endpoint.
+     */
+    segmentValidation(segmentContainerType, segment) {
+        if (segment?.segmentDuration && (segment.segmentDuration?.toSeconds() < 1 || segment.segmentDuration?.toSeconds() > 30)) {
+            throw new core_1.ValidationError((0, helpers_internal_1.lit) `SegmentDurationRange`, 'Segment Duration needs to be between 1-30 seconds.', this);
+        }
+        if (segmentContainerType != ContainerType.TS && (segment?.tsIncludeDvbSubtitles || segment?.tsUseAudioRenditionGroup)) {
+            throw new core_1.ValidationError((0, helpers_internal_1.lit) `TsOptionsIncompatible`, 'Disable TS Segment options for DvbSubtitles and AudioRenditionGroups when using CMAF.', this);
+        }
+        return {
+            includeIframeOnlyStreams: segment?.includeIframeOnlyStreams,
+            segmentDurationSeconds: segment?.segmentDuration?.toSeconds(),
+            segmentName: segment?.segmentName,
+            tsIncludeDvbSubtitles: segment?.tsIncludeDvbSubtitles,
+            tsUseAudioRenditionGroup: segment?.tsUseAudioRenditionGroup,
+            scte: (segment?.scteFilter || segment?.scteInSegments) ? {
+                scteFilter: segment?.scteFilter,
+                scteInSegments: segment?.scteInSegments,
+            } : undefined,
+            encryption: segment?.encryption?._bind(this),
+        };
+    }
+    /**
+     * Create a CloudWatch metric.
+     *
+     * @param metricName name of the metric.
+     * @param props metric options.
+     */
+    metric(metricName, props) {
+        return new aws_cloudwatch_1.Metric({
+            metricName,
+            namespace: 'AWS/MediaPackage',
+            dimensionsMap: {
+                ChannelGroup: this.channelGroupName,
+                Channel: this.channelName,
+                OriginEndpoint: this.originEndpointName,
+            },
+            ...props,
+        }).attachTo(this);
+    }
+    /**
+     * Returns Metric for Ingress Bytes
+     *
+     * @default - sum over 60 seconds
+     */
+    metricIngressBytes(props) {
+        return this.metric('IngressBytes', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.BYTES,
+            ...props,
+        });
+    }
+    /**
+     * Returns Metric for Egress Bytes
+     *
+     * @default - sum over 60 seconds
+     */
+    metricEgressBytes(props) {
+        return this.metric('EgressBytes', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.BYTES,
+            ...props,
+        });
+    }
+    /**
+     * Returns Metric for Ingress response time
+     *
+     * @default - average over 60 seconds
+     */
+    metricIngressResponseTime(props) {
+        return this.metric('IngressResponseTime', {
+            statistic: 'avg',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.MILLISECONDS,
+            ...props,
+        });
+    }
+    /**
+     * Returns Metric for Egress Response time
+     *
+     * @default - average over 60 seconds
+     */
+    metricEgressResponseTime(props) {
+        return this.metric('EgressResponseTime', {
+            statistic: 'avg',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.MILLISECONDS,
+            ...props,
+        });
+    }
+    /**
+     * Returns Metric for Egress Request Count
+     *
+     * @default - sum over 60 seconds
+     */
+    metricEgressRequestCount(props) {
+        return this.metric('EgressRequestCount', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            ...props,
+        });
+    }
+    /**
+     * Returns Metric for Ingress Request Count
+     *
+     * @default - sum over 60 seconds
+     */
+    metricIngressRequestCount(props) {
+        return this.metric('IngressRequestCount', {
+            statistic: 'sum',
+            period: aws_cdk_lib_1.Duration.seconds(60),
+            unit: aws_cloudwatch_1.Unit.COUNT,
+            ...props,
+        });
+    }
+}
+/**
+ * Defines an AWS Elemental MediaPackage V2 Origin Endpoint
+ */
+let OriginEndpoint = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = OriginEndpointBase;
+    var OriginEndpoint = 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);
+            OriginEndpoint = _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-mediapackagev2-alpha.OriginEndpoint", version: "2.247.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-mediapackagev2-alpha.OriginEndpoint';
+        channelGroupName;
+        channelName;
+        originEndpointName;
+        originEndpointArn;
+        /**
+         * The timestamp of the creation of the origin endpoint.
+         */
+        createdAt;
+        /**
+         * The timestamp of the modification of the origin endpoint.
+         */
+        modifiedAt;
+        /**
+         * Array containing Low Latency HLS Manifests created by the OriginEndpoint.
+         */
+        lowLatencyHlsManifestUrls;
+        /**
+         * Array containing HLS Manifests created by the OriginEndpoint.
+         */
+        hlsManifestUrls;
+        /**
+         * Array containing DASH Manifests created by the OriginEndpoint.
+         */
+        dashManifestUrls;
+        /**
+         * Array containing MSS Manifests created by the OriginEndpoint.
+         */
+        mssManifestUrls;
+        /**
+         * The resource policy associated with this origin endpoint.
+         *
+         * If `autoCreatePolicy` is true, an `OriginEndpointPolicy` will be created upon the
+         * first call to addToResourcePolicy(s).
+         */
+        policy;
+        autoCreatePolicy = true;
+        hlsManifests = [];
+        llHlsManifests = [];
+        dashManifests = [];
+        mssManifests = [];
+        segment;
+        constructor(scope, id, props) {
+            super(scope, id, {
+                physicalName: props?.originEndpointName ?? aws_cdk_lib_1.Lazy.string({
+                    produce: () => aws_cdk_lib_1.Names.uniqueResourceName(this, {
+                        maxLength: 256,
+                    }),
+                }),
+            });
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_mediapackagev2_alpha_OriginEndpointProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, OriginEndpoint);
+                }
+                throw error;
+            }
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            // Validate originEndpointName if provided
+            if (props.originEndpointName != null && !aws_cdk_lib_1.Token.isUnresolved(props.originEndpointName)) {
+                if (props.originEndpointName.length < 1 || props.originEndpointName.length > 256) {
+                    throw new core_1.ValidationError((0, helpers_internal_1.lit) `OriginEndpointNameLength`, 'Origin endpoint name must be between 1 and 256 characters in length.', this);
+                }
+                if (!props.originEndpointName.match(/^[a-zA-Z0-9_-]+$/)) {
+                    throw new core_1.ValidationError((0, helpers_internal_1.lit) `OriginEndpointNamePattern`, 'Origin endpoint name must only contain alphanumeric characters, hyphens, and underscores.', this);
+                }
+            }
+            // Validate description if provided
+            if (props.description && !aws_cdk_lib_1.Token.isUnresolved(props.description) && props.description.length > 1024) {
+                throw new core_1.ValidationError((0, helpers_internal_1.lit) `OriginEndpointDescriptionLength`, 'Origin endpoint description must not exceed 1024 characters.', this);
+            }
+            this.segment = props.segment;
+            // Get container type from segment
+            const containerType = props.segment.containerType;
+            if (props?.startoverWindow && (props.startoverWindow.toSeconds() < 60 || props.startoverWindow.toSeconds() > 1209600)) {
+                throw new core_1.ValidationError((0, helpers_internal_1.lit) `StartoverWindowRange`, 'Startover Window needs to be between 60-1209600 seconds.', this);
+            }
+            props.manifests.forEach(manifest => {
+                manifest._bind({
+                    hlsManifests: this.hlsManifests,
+                    llHlsManifests: this.llHlsManifests,
+                    dashManifests: this.dashManifests,
+                    mssManifests: this.mssManifests,
+                    segment: props.segment,
+                });
+            });
+            // Validate manifest and container type compatibility
+            if (this.mssManifests.length > 0 && containerType !== ContainerType.ISM) {
+                throw new core_1.ValidationError((0, helpers_internal_1.lit) `MssRequiresIsm`, 'MSS manifests require ISM container type. Use Segment.ism() for MSS manifests.', this);
+            }
+            if (this.dashManifests.length > 0 && containerType !== ContainerType.CMAF) {
+                throw new core_1.ValidationError((0, helpers_internal_1.lit) `DashRequiresCmaf`, 'DASH manifests require CMAF container type. Use Segment.cmaf() for DASH manifests.', this);
+            }
+            if ((this.hlsManifests.length > 0 || this.llHlsManifests.length > 0) && containerType === ContainerType.ISM) {
+                throw new core_1.ValidationError((0, helpers_internal_1.lit) `HlsIncompatibleWithIsm`, 'HLS and Low Latency HLS manifests are not supported with ISM container type. Use Segment.cmaf() or Segment.ts() for HLS manifests.', this);
+            }
+            // Validate DRM signalling requires encryption
+            if (this.dashManifests.some(m => m.drmSignaling) && !props.segment.encryption) {
+                throw new core_1.ValidationError((0, helpers_internal_1.lit) `DrmSignallingRequiresEncryption`, 'DRM signalling requires encryption to be configured on the endpoint.', this);
+            }
+            const origin = new aws_mediapackagev2_1.CfnOriginEndpoint(this, 'Resource', {
+                channelName: props.channel.channelName,
+                channelGroupName: props.channel.channelGroupName,
+                originEndpointName: this.physicalName,
+                description: props.description,
+                tags: props?.tags ? (0, shared_helpers_1.renderTags)(props.tags) : undefined,
+                hlsManifests: aws_cdk_lib_1.Lazy.any({ produce: () => this.hlsManifests }, { omitEmptyArray: true }),
+                lowLatencyHlsManifests: aws_cdk_lib_1.Lazy.any({ produce: () => this.llHlsManifests }, { omitEmptyArray: true }),
+                dashManifests: aws_cdk_lib_1.Lazy.any({ produce: () => this.dashManifests }, { omitEmptyArray: true }),
+                mssManifests: aws_cdk_lib_1.Lazy.any({ produce: () => this.mssManifests }, { omitEmptyArray: true }),
+                containerType: containerType,
+                startoverWindowSeconds: props.startoverWindow?.toSeconds(),
+                segment: this.segmentValidation(containerType, props.segment),
+                forceEndpointErrorConfiguration: props.forceEndpointConfigurationConditions ? {
+                    endpointErrorConditions: props.forceEndpointConfigurationConditions,
+                } : undefined,
+            });
+            // The channelName/channelGroupName are rendered as literal strings (not CFN Refs), so
+            // CloudFormation cannot infer the dependency. We add direct CfnResource-level DependsOn
+            // to guarantee deploy ordering without triggering CDK's subtree-level cycle detection.
+            // For imported constructs, defaultChild is undefined (no CFN resource to order against).
+            const encryptionRole = props.segment.encryption?._getRole();
+            if (encryptionRole)
+                origin.node.addDependency(encryptionRole);
+            const encryptionCert = props.segment.encryption?._getCertificate();
+            if (encryptionCert)
+                origin.node.addDependency(encryptionCert);
+            const channelCfn = props.channel.node.defaultChild;
+            if (channelCfn && core_1.CfnResource.isCfnResource(channelCfn)) {
+                origin.addDependency(channelCfn);
+            }
+            const groupCfn = props.channel.channelGroup?.node.defaultChild;
+            if (groupCfn && core_1.CfnResource.isCfnResource(groupCfn)) {
+                origin.addDependency(groupCfn);
+            }
+            this.lowLatencyHlsManifestUrls = this.llHlsManifests.map((_, i) => aws_cdk_lib_1.Fn.select(i, origin.attrLowLatencyHlsManifestUrls));
+            this.hlsManifestUrls = this.hlsManifests.map((_, i) => aws_cdk_lib_1.Fn.select(i, origin.attrHlsManifestUrls));
+            this.dashManifestUrls = this.dashManifests.map((_, i) => aws_cdk_lib_1.Fn.select(i, origin.attrDashManifestUrls));
+            this.mssManifestUrls = this.mssManifests.map((_, i) => aws_cdk_lib_1.Fn.select(i, origin.attrMssManifestUrls));
+            this.createdAt = origin.attrCreatedAt;
+            this.modifiedAt = origin.attrModifiedAt;
+            this.channelGroupName = origin.channelGroupName;
+            this.channelName = origin.channelName;
+            this.originEndpointName = origin.originEndpointName;
+            this.originEndpointArn = origin.attrArn;
+            origin.applyRemovalPolicy(props?.removalPolicy ?? aws_cdk_lib_1.RemovalPolicy.DESTROY);
+            // Pre-set CDN auth config if provided in props
+            if (props.cdnAuth) {
+                this._setCdnAuth(props.cdnAuth);
+            }
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return OriginEndpoint = _classThis;
+})();
+exports.OriginEndpoint = OriginEndpoint;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"endpoint.js","sourceRoot":"","sources":["endpoint.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Bitrate, IResource } from 'aws-cdk-lib';\nimport { RemovalPolicy, ArnFormat, Duration, Fn, Lazy, Names, Resource, Stack, Token } from 'aws-cdk-lib';\nimport type { ICertificate } from 'aws-cdk-lib/aws-certificatemanager';\nimport type { MetricOptions } from 'aws-cdk-lib/aws-cloudwatch';\nimport { Metric, Unit } from 'aws-cdk-lib/aws-cloudwatch';\nimport type { IRole, PolicyStatement, AddToResourcePolicyResult } from 'aws-cdk-lib/aws-iam';\nimport { CfnOriginEndpoint } from 'aws-cdk-lib/aws-mediapackagev2';\nimport type { IOriginEndpointRef, OriginEndpointReference } from 'aws-cdk-lib/aws-mediapackagev2';\nimport { ValidationError, UnscopedValidationError, CfnResource } from 'aws-cdk-lib/core';\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 { IChannel } from './channel';\nimport type { CdnAuthConfiguration } from './origin-endpoint-policy';\nimport { OriginEndpointPolicy } from './origin-endpoint-policy';\nimport { convertDateToString, renderTags } from './shared-helpers';\n\n/**\n * Accepted audio codec values for manifest filtering.\n *\n * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html\n */\nexport enum AudioCodec {\n  /** AAC-LC audio codec */\n  AACL = 'AACL',\n  /** HE-AAC audio codec */\n  AACH = 'AACH',\n  /** Dolby Digital audio codec (include the hyphen) */\n  AC_3 = 'AC-3',\n  /** Dolby Digital Plus audio codec (include the hyphen) */\n  EC_3 = 'EC-3',\n}\n\n/**\n * Accepted video codec values for manifest filtering.\n *\n * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html\n */\nexport enum VideoCodec {\n  /** H.264/AVC */\n  H264 = 'H264',\n  /** H.265/HEVC */\n  H265 = 'H265',\n  /** AV1 */\n  AV1 = 'AV1',\n}\n\n/**\n * Accepted video dynamic range values for manifest filtering.\n *\n * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html\n */\nexport enum VideoDynamicRange {\n  /** Dolby Vision */\n  DV = 'dv',\n  /** HDR10 */\n  HDR10 = 'hdr10',\n  /** Hybrid Log-Gamma */\n  HLG = 'hlg',\n  /** Standard Dynamic Range */\n  SDR = 'sdr',\n}\n\n/**\n * Accepted trickplay type values for manifest filtering.\n *\n * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html\n */\nexport enum TrickplayType {\n  /** I-frame only trick-play */\n  IFRAME = 'iframe',\n  /** Image-based trick-play */\n  IMAGE = 'image',\n  /** No trick-play */\n  NONE = 'none',\n}\n\n/**\n * Numeric manifest filter keys.\n *\n * Use with `ManifestFilter.numeric()`, `ManifestFilter.numericList()`, and `ManifestFilter.numericRange()`.\n *\n * Audio and video bitrate filters are not included here because they use the\n * `Bitrate` class directly via dedicated methods on `ManifestFilter`.\n *\n * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html\n */\nexport enum NumericFilterKey {\n  /**\n   * The number of audio channels.\n   *\n   * Accepted values: range 1–32767, or individual integers.\n   */\n  AUDIO_CHANNELS='audio_channels',\n  /**\n   * The audio sample rate in Hz.\n   *\n   * Accepted values: range 0–2147483647, or individual integers.\n   */\n  AUDIO_SAMPLE_RATE='audio_sample_rate',\n  /**\n   * The height of the trick-play image in pixels (I-frame and image-based trick-play).\n   *\n   * If using with I-frame only trick-play, `TRICKPLAY_HEIGHT` and `VIDEO_HEIGHT`\n   * should have similar values. If they differ, I-frame only tracks might be\n   * removed from the manifest.\n   *\n   * Accepted values: range 1–2147483647, or individual integers.\n   */\n  TRICKPLAY_HEIGHT='trickplay_height',\n  /**\n   * The video frame rate range in NTSC format.\n   *\n   * When filtering for a single value, MediaPackage uses an approximate equals\n   * comparison with an epsilon tolerance of 0.0005.\n   *\n   * Accepted values: range 1–999.999 (up to three decimal places), or individual values.\n   */\n  VIDEO_FRAMERATE='video_framerate',\n  /**\n   * The height of the video in pixels.\n   *\n   * If using with I-frame only trick-play, `TRICKPLAY_HEIGHT` and `VIDEO_HEIGHT`\n   * should have similar values. If they differ, I-frame only tracks might be\n   * removed from the manifest.\n   *\n   * Accepted values: range 1–32767, or individual integers.\n   */\n  VIDEO_HEIGHT='video_height',\n}\n\n/**\n * Text manifest filter keys for free-form string values.\n *\n * Use with `ManifestFilter.text()` and `ManifestFilter.textList()`.\n *\n * For keys with fixed accepted values, use the dedicated methods on `ManifestFilter` instead:\n * - Audio codec: `ManifestFilter.audioCodec()` / `ManifestFilter.audioCodecList()`\n * - Video codec: `ManifestFilter.videoCodec()` / `ManifestFilter.videoCodecList()`\n * - Video dynamic range: `ManifestFilter.videoDynamicRange()` / `ManifestFilter.videoDynamicRangeList()`\n * - Trickplay type: `ManifestFilter.trickplayType()` / `ManifestFilter.trickplayTypeList()`\n *\n * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html\n */\nexport enum TextFilterKey {\n  /**\n   * Audio languages or functional codes derived from encoder passthrough.\n   *\n   * Accepted values: arbitrary strings such as ISO-639-1 language codes (not case-sensitive).\n   */\n  AUDIO_LANGUAGE='audio_language',\n  /**\n   * The subtitle language or functional codes derived from encoder passthrough.\n   *\n   * Accepted values: arbitrary strings such as ISO-639-1 language codes (not case-sensitive).\n   */\n  SUBTITLE_LANGUAGE='subtitle_language',\n}\n\n/**\n * Bitrate manifest filter keys.\n *\n * Use with `ManifestFilter.bitrate()` and `ManifestFilter.bitrateRange()`.\n *\n * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html\n */\nexport enum BitrateFilterKey {\n  /**\n   * The audio bitrate in bits per second.\n   *\n   * Accepted values: range 0–2147483647, or individual integers.\n   */\n  AUDIO_BITRATE='audio_bitrate',\n  /**\n   * The video bitrate in bits per second.\n   *\n   * We recommend using only this filter parameter to set the video bitrate.\n   * Do not also set the minimum and maximum video bitrate via the MediaPackage\n   * console or AWS CLI, as your output might be skewed.\n   *\n   * This parameter cannot be used with trick-play streams.\n   *\n   * Accepted values: range 0–2147483647, or individual integers.\n   */\n  VIDEO_BITRATE='video_bitrate',\n}\n\n/**\n * Represents a numeric filter expression segment — either a single value or a range.\n *\n * Use with `ManifestFilter.numericCombo()` to build filters that combine\n * ranges and individual values (e.g. `video_height:240-360,720-1080,1440`).\n */\nexport class NumericExpression {\n  /**\n   * A single numeric value.\n   */\n  public static value(v: number): NumericExpression {\n    return new NumericExpression(`${v}`, [v]);\n  }\n\n  /**\n   * An inclusive numeric range.\n   */\n  public static range(start: number, end: number): NumericExpression {\n    return new NumericExpression(`${start}-${end}`, [start, end]);\n  }\n\n  protected constructor(\n    /** @internal */\n    public readonly _expression: string,\n    /** @internal */\n    public readonly _values: number[],\n  ) {}\n}\n\n/**\n * Represents a bitrate filter expression segment — either a single value or a range.\n *\n * Use with `ManifestFilter.bitrateCombo()` to build filters that combine\n * ranges and individual bitrate values.\n */\nexport class BitrateExpression {\n  /**\n   * A single bitrate value.\n   */\n  public static value(v: Bitrate): BitrateExpression {\n    return new BitrateExpression(`${v.toBps()}`, [v.toBps()]);\n  }\n\n  /**\n   * An inclusive bitrate range.\n   */\n  public static range(start: Bitrate, end: Bitrate): BitrateExpression {\n    return new BitrateExpression(`${start.toBps()}-${end.toBps()}`, [start.toBps(), end.toBps()]);\n  }\n\n  protected constructor(\n    /** @internal */\n    public readonly _expression: string,\n    /** @internal */\n    public readonly _values: number[],\n  ) {}\n}\n\n/**\n * Enables you to create filters for your Origin Endpoint.\n *\n * @see https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filtering.html\n */\nexport class ManifestFilter {\n  /**\n   * Filter by a single bitrate value.\n   */\n  public static bitrate(key: BitrateFilterKey, value: Bitrate) {\n    const bps = value.toBps();\n    validateBitrateFilterValue(bps, key);\n    return new ManifestFilter(`${key}:${bps}`);\n  }\n\n  /**\n   * Filter by a bitrate range (inclusive).\n   */\n  public static bitrateRange(key: BitrateFilterKey, start: Bitrate, end: Bitrate) {\n    const startBps = start.toBps();\n    const endBps = end.toBps();\n    validateBitrateFilterValue(startBps, key);\n    validateBitrateFilterValue(endBps, key);\n    return new ManifestFilter(`${key}:${startBps}-${endBps}`);\n  }\n\n  /**\n   * Specify a single numeric filter value.\n   */\n  public static numeric(key: NumericFilterKey, value: number) {\n    validateNumericFilterValue(value, key);\n    return new ManifestFilter(`${key}:${value}`);\n  }\n\n  /**\n   * Specify multiple numeric filter values.\n   */\n  public static numericList(key: NumericFilterKey, values: number[]) {\n    values.forEach(v => validateNumericFilterValue(v, key));\n    return new ManifestFilter(`${key}:${values.join(',')}`);\n  }\n\n  /**\n   * Specify a numeric filter range (inclusive).\n   */\n  public static numericRange(key: NumericFilterKey, start: number, end: number) {\n    validateNumericFilterValue(start, key);\n    validateNumericFilterValue(end, key);\n    return new ManifestFilter(`${key}:${start}-${end}`);\n  }\n\n  /**\n   * Specify a free-form text filter value (for language keys).\n   */\n  public static text(key: TextFilterKey, value: string) {\n    return new ManifestFilter(`${key}:${value}`);\n  }\n\n  /**\n   * Specify multiple free-form text filter values (for language keys).\n   */\n  public static textList(key: TextFilterKey, values: string[]) {\n    return new ManifestFilter(`${key}:${values.join(',')}`);\n  }\n\n  /**\n   * Filter by a single audio codec.\n   */\n  public static audioCodec(value: AudioCodec) {\n    return new ManifestFilter(`audio_codec:${value}`);\n  }\n\n  /**\n   * Filter by multiple audio codecs.\n   */\n  public static audioCodecList(values: AudioCodec[]) {\n    return new ManifestFilter(`audio_codec:${values.join(',')}`);\n  }\n\n  /**\n   * Filter by a single video codec.\n   */\n  public static videoCodec(value: VideoCodec) {\n    return new ManifestFilter(`video_codec:${value}`);\n  }\n\n  /**\n   * Filter by multiple video codecs.\n   */\n  public static videoCodecList(values: VideoCodec[]) {\n    return new ManifestFilter(`video_codec:${values.join(',')}`);\n  }\n\n  /**\n   * Filter by a single video dynamic range.\n   */\n  public static videoDynamicRange(value: VideoDynamicRange) {\n    return new ManifestFilter(`video_dynamic_range:${value}`);\n  }\n\n  /**\n   * Filter by multiple video dynamic ranges.\n   */\n  public static videoDynamicRangeList(values: VideoDynamicRange[]) {\n    return new ManifestFilter(`video_dynamic_range:${values.join(',')}`);\n  }\n\n  /**\n   * Filter by a single trickplay type.\n   */\n  public static trickplayType(value: TrickplayType) {\n    return new ManifestFilter(`trickplay_type:${value}`);\n  }\n\n  /**\n   * Filter by multiple trickplay types.\n   */\n  public static trickplayTypeList(values: TrickplayType[]) {\n    return new ManifestFilter(`trickplay_type:${values.join(',')}`);\n  }\n\n  /**\n   * Filter by a combination of numeric ranges and individual values.\n   *\n   * Use this for advanced patterns like `video_height:240-360,720-1080,1440`.\n   *\n   * @example\n   * ManifestFilter.numericCombo(NumericFilterKey.VIDEO_HEIGHT, [\n   *   NumericExpression.range(240, 360),\n   *   NumericExpression.range(720, 1080),\n   *   NumericExpression.value(1440),\n   * ])\n   */\n  public static numericCombo(key: NumericFilterKey, expressions: NumericExpression[]) {\n    expressions.forEach(expr => expr._values.forEach(v => validateNumericFilterValue(v, key)));\n    return new ManifestFilter(`${key}:${expressions.map(e => e._expression).join(',')}`);\n  }\n\n  /**\n   * Filter by a combination of bitrate ranges and individual values.\n   *\n   * @example\n   * ManifestFilter.bitrateCombo(BitrateFilterKey.VIDEO_BITRATE, [\n   *   BitrateExpression.range(Bitrate.mbps(1), Bitrate.mbps(3)),\n   *   BitrateExpression.value(Bitrate.mbps(5)),\n   * ])\n   */\n  public static bitrateCombo(key: BitrateFilterKey, expressions: BitrateExpression[]) {\n    expressions.forEach(expr => expr._values.forEach(v => validateBitrateFilterValue(v, key)));\n    return new ManifestFilter(`${key}:${expressions.map(e => e._expression).join(',')}`);\n  }\n\n  /**\n   * Specify a custom manifest filter string.\n   */\n  public static custom(custom: string) {\n    return new ManifestFilter(custom);\n  }\n\n  /**\n   * @param filterString Normalised manifest filter string\n   */\n  protected constructor(public readonly filterString: string) { }\n}\n\n/**\n * Context passed to Manifest._bind() method\n * @internal\n */\nexport interface ManifestBindContext {\n  readonly hlsManifests: CfnOriginEndpoint.HlsManifestConfigurationProperty[];\n  readonly llHlsManifests: CfnOriginEndpoint.LowLatencyHlsManifestConfigurationProperty[];\n  readonly dashManifests: CfnOriginEndpoint.DashManifestConfigurationProperty[];\n  readonly mssManifests: CfnOriginEndpoint.MssManifestConfigurationProperty[];\n  readonly segment?: SegmentConfiguration;\n}\n\n/**\n * Manifest to add to Origin Endpoint\n */\nexport abstract class Manifest {\n  /**\n   * Specify a manifest configuration for Low Latency HLS.\n   *\n   * **Note:** Low Latency HLS manifests require TS or CMAF container type.\n   * Use with `Segment.ts()` or `Segment.cmaf()`.\n   */\n  public static lowLatencyHLS(manifest: LowLatencyHlsManifestConfiguration): Manifest {\n    return new LowLatencyHlsManifest(manifest);\n  }\n\n  /**\n   * Specify a manifest configuration for HLS.\n   *\n   * **Note:** HLS manifests require TS or CMAF container type.\n   * Use with `Segment.ts()` or `Segment.cmaf()`.\n   */\n  public static hls(manifest: HlsManifestConfiguration): Manifest {\n    return new HlsManifest(manifest);\n  }\n\n  /**\n   * Specify a manifest configuration for DASH.\n   *\n   * **Note:** DASH manifests require CMAF container type.\n   * Use with `Segment.cmaf()`.\n   */\n  public static dash(manifest: DashManifestConfiguration): Manifest {\n    return new DashManifest(manifest);\n  }\n\n  /**\n   * Specify a manifest configuration for MSS.\n   *\n   * **Note:** MSS manifests require ISM container type.\n   * Use with `Segment.ism()`.\n   */\n  public static mss(manifest: MssManifestConfiguration): Manifest {\n    return new MssManifest(manifest);\n  }\n\n  /**\n   * Called when the manifest is bound to an OriginEndpoint.\n   *\n   * This is an internal method used by the construct library and should not be\n   * called or implemented by external consumers. It may change without notice.\n   *\n   * @internal\n   */\n  public abstract _bind(context: ManifestBindContext): void;\n}\n\n/**\n * Validate a numeric filter value is an integer within the accepted range for its key.\n * VIDEO_FRAMERATE is excluded — it uses `validateFramerateValue` instead.\n * @internal\n */\nfunction validateIntegerFilterValue(value: number, key: NumericFilterKey, min: number, max: number): void {\n  if (!Number.isInteger(value)) {\n    throw new UnscopedValidationError(lit`NumericFilterMustBeInteger`, `Numeric filter value for '${key}' must be an integer, got ${value}`);\n  }\n  if (value < min || value > max) {\n    throw new UnscopedValidationError(lit`NumericFilterOutOfRange`, `Numeric filter value for '${key}' must be between ${min} and ${max}, got ${value}`);\n  }\n}\n\n/**\n * Validate a video framerate filter value (1–999.999, up to 3 decimal places).\n * @internal\n */\nfunction validateFramerateValue(value: number): void {\n  if (value < 1 || value > 999.999) {\n    throw new UnscopedValidationError(lit`NumericFilterOutOfRange`, `Numeric filter value for 'video_framerate' must be between 1 and 999.999, got ${value}`);\n  }\n  const decimalPart = value.toString().split('.')[1];\n  if (decimalPart && decimalPart.length > 3) {\n    throw new UnscopedValidationError(lit`NumericFilterMaxDecimalPlaces`, `Numeric filter value for 'video_framerate' allows up to 3 decimal places, got ${value}`);\n  }\n}\n\n/**\n * Route numeric validation to the correct helper based on key.\n * @internal\n */\nfunction validateNumericFilterValue(value: number, key: NumericFilterKey): void {\n  switch (key) {\n    case NumericFilterKey.AUDIO_CHANNELS:\n      return validateIntegerFilterValue(value, key, 1, 32_767);\n    case NumericFilterKey.AUDIO_SAMPLE_RATE:\n      return validateIntegerFilterValue(value, key, 0, 2_147_483_647);\n    case NumericFilterKey.TRICKPLAY_HEIGHT:\n      return validateIntegerFilterValue(value, key, 1, 2_147_483_647);\n    case NumericFilterKey.VIDEO_FRAMERATE:\n      return validateFramerateValue(value);\n    case NumericFilterKey.VIDEO_HEIGHT:\n      return validateIntegerFilterValue(value, key, 1, 32_767);\n  }\n}\n\n/**\n * Validate a bitrate filter value is an integer within the accepted range.\n * @internal\n */\nfunction validateBitrateFilterValue(bps: number, key: BitrateFilterKey): void {\n  if (!Number.isInteger(bps)) {\n    throw new UnscopedValidationError(lit`BitrateFilterMustBeInteger`, `Bitrate filter value for '${key}' must resolve to a whole number of bits per second, got ${bps}`);\n  }\n  if (bps < 0 || bps > 2_147_483_647) {\n    throw new UnscopedValidationError(lit`BitrateFilterOutOfRange`, `Bitrate filter value for '${key}' must be between 0 and 2147483647, got ${bps}`);\n  }\n}\n\n/**\n * Validates common manifest configuration properties\n */\nfunction validateManifestConfiguration(config: ManifestConfigurationBase): void {\n  if (config.manifestWindow && config.manifestWindow.toSeconds() < 30) {\n    throw new UnscopedValidationError(lit`ManifestWindowMinimum`, 'Manifest Window has a minimum value of 30 seconds');\n  }\n}\n\n/**\n * Validate and modify filter configuration\n * @internal\n */\nfunction validateFilterConfiguration(filterConfig?: FilterConfiguration): CfnOriginEndpoint.FilterConfigurationProperty | undefined {\n  if (!filterConfig) return undefined;\n\n  if (filterConfig.clipStartTime && (filterConfig.start || filterConfig.end)) {\n    throw new UnscopedValidationError(lit`ClipStartTimeConflict`, 'You cannot specify both ClipStartTime with Start or End in a FilterConfiguration.');\n  }\n\n  if (filterConfig.timeDelay && (filterConfig.timeDelay.toSeconds() < 0 || filterConfig.timeDelay.toSeconds() > 1209600)) {\n    throw new UnscopedValidationError(lit`TimeDelayRange`, 'Time Delay setting should be defined between 0-1209600 seconds.');\n  }\n\n  if (filterConfig.start && filterConfig.end && (filterConfig.end <= filterConfig.start)) {\n    throw new UnscopedValidationError(lit`EndBeforeStart`, 'The End parameter needs to be after the Start parameter in a FilterConfiguration.');\n  }\n\n  const manifestFilter = filterConfig.manifestFilter ? filterConfig.manifestFilter.map(filter => filter.filterString).join(';') : undefined;\n  if (manifestFilter != undefined && (manifestFilter.length < 1 || manifestFilter.length > 1024)) {\n    throw new UnscopedValidationError(lit`ManifestFilterLength`, 'Manifest filter needs to be between 1-1024 characters in length.');\n  }\n\n  if (filterConfig.manifestFilter && filterConfig.manifestFilter.length > 1) {\n    const keys = filterConfig.manifestFilter.map(f => f.filterString.split(':')[0]);\n    keys.forEach((key, i) => {\n      if (keys.indexOf(key) !== i) {\n        throw new UnscopedValidationError(lit`DuplicateManifestFilterKey`, `Duplicate manifest filter key '${key}'. Use a single filter with comma-separated values instead (e.g. ManifestFilter.numericList() or ManifestFilter.custom()).`);\n      }\n    });\n  }\n\n  return {\n    manifestFilter,\n    drmSettings: filterConfig.drmSettings ? filterConfig.drmSettings.filter((v, i, a) => a.indexOf(v) === i).join(';') : undefined,\n    clipStartTime: filterConfig.clipStartTime ? convertDateToString(filterConfig.clipStartTime) : undefined,\n    start: filterConfig.start ? convertDateToString(filterConfig.start) : undefined,\n    end: filterConfig.end ? convertDateToString(filterConfig.end) : undefined,\n    timeDelaySeconds: filterConfig.timeDelay?.toSeconds(),\n  };\n}\n\n/**\n * Validate startTag configuration\n * @internal\n */\nfunction validateStartTag(startTag: StartTag, manifestWindow?: Duration, segmentDuration?: Duration): void {\n  const timeOffset = startTag.timeOffset;\n\n  // Get segment duration (default is 6 seconds if not specified)\n  const segmentDurationSec = segmentDuration?.toSeconds() ?? 6;\n\n  // Get manifest duration (default is 60 seconds if not specified)\n  const manifestDurationSec = manifestWindow?.toSeconds() ?? 60;\n\n  // Validate positive offset (from start)\n  if (timeOffset > 0) {\n    const maxPositiveOffset = manifestDurationSec - (3 * segmentDurationSec);\n    if (timeOffset >= maxPositiveOffset) {\n      throw new UnscopedValidationError(lit`StartTagPositiveOffsetExceeded`, `StartTag timeOffset (${timeOffset}s) must be less than manifest duration (${manifestDurationSec}s) minus 3 times segment duration (${segmentDurationSec}s). Maximum allowed: ${maxPositiveOffset}s`);\n    }\n  }\n\n  // Validate negative offset (from live edge)\n  if (timeOffset < 0) {\n    const absOffset = Math.abs(timeOffset);\n    const minNegativeOffset = 3 * segmentDurationSec;\n\n    if (absOffset <= minNegativeOffset) {\n      throw new UnscopedValidationError(lit`StartTagNegativeOffsetTooSmall`, `StartTag timeOffset (${timeOffset}s) absolute value must be greater than 3 times segment duration (${segmentDurationSec}s). Minimum allowed: -${minNegativeOffset + 0.01}s`);\n    }\n\n    if (absOffset >= manifestDurationSec) {\n      throw new UnscopedValidationError(lit`StartTagNegativeOffsetExceedsManifest`, `StartTag timeOffset (${timeOffset}s) absolute value must be less than manifest duration (${manifestDurationSec}s)`);\n    }\n  }\n}\n\n/**\n * Build HLS manifest configuration\n * @internal\n */\nfunction buildHlsManifestConfiguration(\n  config: HlsManifestConfiguration,\n  segmentDuration?: Duration,\n): CfnOriginEndpoint.HlsManifestConfigurationProperty {\n  if (config.startTag) {\n    validateStartTag(config.startTag, config.manifestWindow, segmentDuration);\n  }\n\n  return {\n    manifestName: config.manifestName,\n    childManifestName: config.childManifestName,\n    manifestWindowSeconds: config.manifestWindow?.toSeconds(),\n    programDateTimeIntervalSeconds: config.programDateTimeInterval?.toSeconds(),\n    scteHls: config.scteAdMarkerHls ? { adMarkerHls: config.scteAdMarkerHls } : undefined,\n    startTag: config.startTag,\n    urlEncodeChildManifest: config.urlEncodeChildManifest,\n    filterConfiguration: validateFilterConfiguration(config.filterConfiguration),\n  };\n}\n\n/**\n * Build DASH manifest configuration\n * @internal\n */\nfunction buildDashManifestConfiguration(\n  config: DashManifestConfiguration,\n  segment?: SegmentConfiguration,\n): CfnOriginEndpoint.DashManifestConfigurationProperty {\n  if (config.minBufferTime && (config.minBufferTime.toSeconds() < 1 || config.minBufferTime.toSeconds() > 3600)) {\n    throw new UnscopedValidationError(lit`MinBufferTimeRange`, 'Min buffer time has a range from 1 sec. to 3600 sec.');\n  }\n  if (config.minUpdatePeriod && (config.minUpdatePeriod.toSeconds() < 1 || config.minUpdatePeriod.toSeconds() > 3600)) {\n    throw new UnscopedValidationError(lit`MinUpdatePeriodRange`, 'Min update period option has a range from 1 sec. to 3600 sec.');\n  }\n  if (config.scteDashAdMarker && (!segment?.scteFilter || segment.scteFilter?.length === 0)) {\n    throw new UnscopedValidationError(lit`ScteFilterRequired`, 'SCTE Filter must be configured with DashAdMarker Configuration');\n  }\n\n  return {\n    manifestName: config.manifestName,\n    baseUrls: config.baseUrls,\n    compactness: config.compactness,\n    drmSignaling: config.drmSignalling,\n    dvbSettings: config.dvbSettings,\n    profiles: config.profiles,\n    programInformation: config.programInformation,\n    subtitleConfiguration: config.subtitleConfiguration,\n    manifestWindowSeconds: config.manifestWindow?.toSeconds(),\n    minBufferTimeSeconds: config.minBufferTime?.toSeconds(),\n    minUpdatePeriodSeconds: config.minUpdatePeriod?.toSeconds(),\n    suggestedPresentationDelaySeconds: config.suggestedPresentationDelay?.toSeconds(),\n    segmentTemplateFormat: config.segmentTemplateFormat,\n    periodTriggers: config.periodTriggers,\n    scteDash: segment?.scteFilter ? {\n      adMarkerDash: config.scteDashAdMarker,\n    } : undefined,\n    utcTiming: config.utcTimingMode || config.utcTimingSource ? {\n      timingMode: config.utcTimingMode,\n      timingSource: config.utcTimingSource,\n    } : undefined,\n    filterConfiguration: validateFilterConfiguration(config.filterConfiguration),\n  };\n}\n\n/**\n * Build MSS manifest configuration\n * @internal\n */\nfunction buildMssManifestConfiguration(config: MssManifestConfiguration): CfnOriginEndpoint.MssManifestConfigurationProperty {\n  return {\n    manifestName: config.manifestName,\n    manifestLayout: config.manifestLayout,\n    manifestWindowSeconds: config.manifestWindow?.toSeconds(),\n    filterConfiguration: validateFilterConfiguration(config.filterConfiguration),\n  };\n}\n\n/**\n * HLS Manifest implementation\n */\nclass HlsManifest extends Manifest {\n  constructor(private readonly config: HlsManifestConfiguration) {\n    super();\n  }\n\n  public _bind(context: ManifestBindContext): void {\n    validateManifestConfiguration(this.config);\n    context.hlsManifests.push(buildHlsManifestConfiguration(this.config, context.segment?.segmentDuration));\n  }\n}\n\n/**\n * Low Latency HLS Manifest implementation\n */\nclass LowLatencyHlsManifest extends Manifest {\n  constructor(private readonly config: LowLatencyHlsManifestConfiguration) {\n    super();\n  }\n\n  public _bind(context: ManifestBindContext): void {\n    validateManifestConfiguration(this.config);\n    context.llHlsManifests.push(buildHlsManifestConfiguration(this.config, context.segment?.segmentDuration));\n  }\n}\n\n/**\n * DASH Manifest implementation\n */\nclass DashManifest extends Manifest {\n  constructor(private readonly config: DashManifestConfiguration) {\n    super();\n  }\n\n  public _bind(context: ManifestBindContext): void {\n    validateManifestConfiguration(this.config);\n\n    if (this.config.utcTimingMode === DashUtcTimingMode.UTC_DIRECT && this.config.utcTimingSource) {\n      throw new UnscopedValidationError(lit`UtcDirectTimingSource`, 'UTC Direct configured with a timing source, ensure timing source is undefined to use UTC Direct.');\n    }\n\n    context.dashManifests.push(buildDashManifestConfiguration(this.config, context.segment));\n  }\n}\n\n/**\n * MSS Manifest implementation\n */\nclass MssManifest extends Manifest {\n  constructor(private readonly config: MssManifestConfiguration) {\n    super();\n  }\n\n  public _bind(context: ManifestBindContext): void {\n    validateManifestConfiguration(this.config);\n    context.mssManifests.push(buildMssManifestConfiguration(this.config));\n  }\n}\n\n/**\n * The type of container to attach to this origin endpoint.\n * A container type is a file format that encapsulates one or more media streams, such as audio and video, into a single file. You can't change the container type after you create the endpoint.\n */\nexport enum ContainerType {\n  /**\n   * TS Container Type\n   */\n  TS='TS',\n  /**\n   * CMAF Container Type\n   */\n  CMAF='CMAF',\n  /**\n   * ISM Container Type (Microsoft Smooth Streaming)\n   */\n  ISM='ISM',\n}\n\n/**\n * Encryption methods for CMAF container type.\n */\nexport enum CmafEncryptionMethod {\n  /**\n   * Common Encryption Scheme (CENC) - compatible with PlayReady, Widevine, and Irdeto DRM systems.\n   */\n  CENC = 'CENC',\n  /**\n   * Common Encryption Scheme with CBCS mode - compatible with PlayReady, Widevine, and FairPlay DRM systems.\n   */\n  CBCS = 'CBCS',\n}\n\n/**\n * Encryption methods for TS container type.\n */\nexport enum TsEncryptionMethod {\n  /**\n   * AES-128 encryption - requires Clear Key AES 128 DRM system.\n   */\n  AES_128 = 'AES_128',\n  /**\n   * Sample-level AES encryption - requires FairPlay DRM system.\n   */\n  SAMPLE_AES = 'SAMPLE_AES',\n}\n\n/**\n * A collection of audio encryption presets.\n */\nexport enum PresetSpeke20Audio {\n  /**\n   * Use one content key to encrypt all of the audio tracks in your stream.\n   */\n  PRESET_AUDIO_1='PRESET_AUDIO_1',\n  /**\n   * Use one content key to encrypt all of the stereo audio tracks and one content key to encrypt all of the multichannel audio tracks.\n   */\n  PRESET_AUDIO_2='PRESET_AUDIO_2',\n  /**\n   * Use one content key to encrypt all of the stereo audio tracks, one content key to encrypt all of the multichannel audio tracks with 3 to 6 channels,\n   * and one content key to encrypt all of the multichannel audio tracks with more than 6 channels.\n   */\n  PRESET_AUDIO_3='PRESET_AUDIO_3',\n  /**\n   * Use the same content key for all of the audio and video tracks in your stream.\n   */\n  SHARED='SHARED',\n  /**\n   * Don't encrypt any of the audio tracks in your stream.\n   */\n  UNENCRYPTED='UNENCRYPTED',\n}\n\n/**\n * The SPEKE Version 2.0 preset video associated with the encryption contract configuration of the origin endpoint.\n *\n * A collection of video encryption presets.\n */\nexport enum PresetSpeke20Video {\n  /**\n   * Use one content key to encrypt all of the video tracks in your stream.\n   */\n  PRESET_VIDEO_1='PRESET_VIDEO_1',\n  /**\n   * Use one content key to encrypt all of the SD video tracks and one content key for all HD and higher resolutions video tracks.\n   */\n  PRESET_VIDEO_2='PRESET_VIDEO_2',\n  /**\n   * Use one content key to encrypt all of the SD video tracks, one content key for HD video tracks and one content key for all UHD video tracks.\n   */\n  PRESET_VIDEO_3='PRESET_VIDEO_3',\n  /**\n   * Use one content key to encrypt all of the SD video tracks, one content key for HD video tracks,\n   * one content key for all UHD1 video tracks and one content key for all UHD2 video tracks.\n   */\n  PRESET_VIDEO_4='PRESET_VIDEO_4',\n  /**\n   * Use one content key to encrypt all of the SD video tracks, one content key for HD1 video tracks, one content key for HD2 video tracks,\n   * one content key for all UHD1 video tracks and one content key for all UHD2 video tracks.\n   */\n  PRESET_VIDEO_5='PRESET_VIDEO_5',\n  /**\n   * Use one content key to encrypt all of the SD video tracks, one content key for HD1 video tracks, one content key for HD2 video tracks\n   * and one content key for all UHD video tracks.\n   */\n  PRESET_VIDEO_6='PRESET_VIDEO_6',\n  /**\n   * Use one content key to encrypt all of the SD+HD1 video tracks, one content key for HD2 video tracks and one content key for all UHD video tracks.\n   */\n  PRESET_VIDEO_7='PRESET_VIDEO_7',\n  /**\n   * Use one content key to encrypt all of the SD+HD1 video tracks, one content key for HD2 video tracks, one content key for all UHD1\n   * video tracks and one content key for all UHD2 video tracks.\n   */\n  PRESET_VIDEO_8='PRESET_VIDEO_8',\n  /**\n   * Use the same content key for all of the video and audio tracks in your stream.\n   */\n  SHARED='SHARED',\n  /**\n   * Don't encrypt any of the video tracks in your stream.\n   */\n  UNENCRYPTED='UNENCRYPTED',\n}\n\n/**\n * Endpoint error configuration options.\n */\nexport enum EndpointErrorConfiguration {\n  /**\n   * The manifest stalled and there are no new segments or parts.\n   */\n  STALE_MANIFEST='STALE_MANIFEST',\n  /**\n   * There is a gap in the manifest.\n   */\n  INCOMPLETE_MANIFEST='INCOMPLETE_MANIFEST',\n  /**\n   * Key rotation is enabled but we're unable to fetch the key for the current key period.\n   */\n  MISSING_DRM_KEY='MISSING_DRM_KEY',\n  /**\n   * The segments which contain slate content are considered to be missing content.\n   */\n  SLATE_INPUT='SLATE_INPUT',\n}\n\n/**\n * SCTE-35 message type options available.\n */\nexport enum ScteMessageType {\n  /**\n   * Option for SPLICE_INSERT.\n   */\n  SPLICE_INSERT='SPLICE_INSERT',\n  /**\n   * Option for BREAK.\n   */\n  BREAK='BREAK',\n  /**\n   * Option for PROVIDER_ADVERTISEMENT.\n   */\n  PROVIDER_ADVERTISEMENT='PROVIDER_ADVERTISEMENT',\n  /**\n   * Option for DISTRIBUTOR_ADVERTISEMENT.\n   */\n  DISTRIBUTOR_ADVERTISEMENT='DISTRIBUTOR_ADVERTISEMENT',\n  /**\n   * Option for PROVIDER_PLACEMENT_OPPORTUNITY.\n   */\n  PROVIDER_PLACEMENT_OPPORTUNITY='PROVIDER_PLACEMENT_OPPORTUNITY',\n  /**\n   * Option for DISTRIBUTOR_PLACEMENT_OPPORTUNITY.\n   */\n  DISTRIBUTOR_PLACEMENT_OPPORTUNITY='DISTRIBUTOR_PLACEMENT_OPPORTUNITY',\n  /**\n   * Option for PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY.\n   */\n  PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY='PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY',\n  /**\n   * Option for DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY.\n   */\n  DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY='DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY',\n  /**\n   * Option for PROGRAM.\n   */\n  PROGRAM='PROGRAM',\n}\n\n/**\n * Controls whether SCTE-35 messages are included in segment files.\n */\nexport enum ScteInSegments {\n  /**\n   * SCTE-35 messages are not included in segments.\n   */\n  NONE = 'NONE',\n  /**\n   * SCTE-35 messages are embedded in segment data.\n   *\n   * For DASH manifests, when set to ALL, an InbandEventStream tag signals\n   * that SCTE messages are present in segments.\n   */\n  ALL = 'ALL',\n}\n\n/**\n * Origin Endpoint interface\n */\nexport interface IOriginEndpoint extends IResource, IOriginEndpointRef {\n  /**\n   * The name of the channel group associated with the origin endpoint configuration.\n   *\n   * @attribute\n   */\n  readonly channelGroupName: string;\n\n  /**\n   * The channel name associated with the origin endpoint.\n   *\n   * @attribute\n   */\n  readonly channelName: string;\n\n  /**\n   * The name of the origin endpoint associated with the origin endpoint configuration.\n   *\n   * @attribute\n   */\n  readonly originEndpointName: string;\n\n  /**\n   * The Amazon Resource Name (ARN) of the origin endpoint.\n   *\n   * @attribute\n   */\n  readonly originEndpointArn: string;\n\n  /**\n   * The date and time the origin endpoint was created.\n   *\n   * @attribute\n   */\n  readonly createdAt?: string;\n\n  /**\n   * The date and time the origin endpoint was modified.\n   *\n   * @attribute\n   */\n  readonly modifiedAt?: string;\n\n  /**\n   * The HLS manifest URLs for the origin endpoint.\n   *\n   * @attribute\n   */\n  readonly hlsManifestUrls?: string[];\n\n  /**\n   * The Low Latency HLS manifest URLs for the origin endpoint.\n   *\n   * @attribute\n   */\n  readonly lowLatencyHlsManifestUrls?: string[];\n\n  /**\n   * The DASH manifest URLs for the origin endpoint.\n   *\n   * @attribute\n   */\n  readonly dashManifestUrls?: string[];\n\n  /**\n   * The MSS manifest URLs for the origin endpoint.\n   *\n   * @attribute\n   */\n  readonly mssManifestUrls?: string[];\n\n  /**\n   * Configure origin endpoint policy.\n   *\n   * You can only add 1 OriginEndpointPolicy to an OriginEndpoint.\n   * If you have already defined one, it will append to the policy already created.\n   *\n   * @param statement - The policy statement to add\n   * @param cdnAuth - Optional CDN authorization configuration. Only the first CDN auth configuration is used if provided multiple times.\n   */\n  addToResourcePolicy(statement: PolicyStatement, cdnAuth?: CdnAuthConfiguration): AddToResourcePolicyResult;\n\n  /**\n   * Create a CloudWatch metric.\n   *\n   * @param metricName name of the metric.\n   * @param props metric options.\n   */\n  metric(metricName: string, props?: MetricOptions): Metric;\n\n  /**\n   * Returns Metric for Ingress Bytes\n   *\n   * @default - sum over 60 seconds\n   */\n  metricIngressBytes(options?: MetricOptions): Metric;\n\n  /**\n   * Returns Metric for Egress Bytes\n   *\n   * @default - sum over 60 seconds\n   */\n  metricEgressBytes(props?: MetricOptions): Metric;\n\n  /**\n   * Returns Metric for Ingress response time\n   *\n   * @default - average over 60 seconds\n   */\n  metricIngressResponseTime(props?: MetricOptions): Metric;\n\n  /**\n   * Returns Metric for Egress Response time\n   *\n   * @default - average over 60 seconds\n   */\n  metricEgressResponseTime(props?: MetricOptions): Metric;\n\n  /**\n   * Returns Metric for Egress Request Count\n   *\n   * @default - sum over 60 seconds\n   */\n  metricEgressRequestCount(props?: MetricOptions): Metric;\n\n  /**\n   * Returns Metric for Ingress Request Count\n   *\n   * @default - sum over 60 seconds\n   */\n  metricIngressRequestCount(props?: MetricOptions): Metric;\n}\n\n/**\n * DRM settings keys for manifest filter configuration.\n */\nexport enum DrmSettingsKey {\n  /**\n   * Exclude EXT-X-SESSION-KEY tags from HLS and LL-HLS multivariant playlists.\n   *\n   * This can improve compatibility with legacy HLS clients that have issues\n   * processing session keys, or provide more granular access control when\n   * using manifest filtering.\n   */\n  EXCLUDE_SESSION_KEYS = 'exclude_session_keys',\n}\n\n/**\n * Filter configuration includes settings for manifest filtering, start and end times, and time delay that apply to all of your egress requests for this manifest.\n */\nexport interface FilterConfiguration {\n  /**\n   * Optionally specify the clip start time for all of your manifest egress requests.\n   * When you include clip start time, note that you cannot use clip start time query parameters for this manifest's endpoint URL.\n   *\n   * This will be converted to a UTC timestamp.\n   *\n   * @default - No clip start time\n   */\n  readonly clipStartTime?: Date;\n  /**\n   * Optionally specify the end time for all of your manifest egress requests.\n   * When you include end time, note that you cannot use end time query parameters for this manifest's endpoint URL.\n   *\n   * This will be converted to a UTC timestamp.\n   *\n   * @default - No end time\n   */\n  readonly end?: Date;\n  /**\n   * Optionally specify the start time for all of your manifest egress requests.\n   * When you include start time, note that you cannot use start time query parameters for this manifest's endpoint URL.\n   *\n   * This will be converted to a UTC timestamp.\n   *\n   * @default - No start time\n   */\n  readonly start?: Date;\n  /**\n   * Optionally specify one or more manifest filters for all of your manifest egress requests.\n   * When you include a manifest filter, note that you cannot use an identical manifest filter query parameter for this manifest's endpoint URL.\n   *\n   * @default - No manifest filters\n   */\n  readonly manifestFilter?: ManifestFilter[];\n  /**\n   * Optionally specify the time delay for all of your manifest egress requests. Enter a value that is smaller than your endpoint's startover window.\n   * When you include time delay, note that you cannot use time delay query parameters for this manifest's endpoint URL.\n   *\n   * @default - No time delay\n   */\n  readonly timeDelay?: Duration;\n  /**\n   * DRM settings for manifest egress requests.\n   *\n   * When you include a DRM setting, note that you cannot use an identical\n   * DRM setting query parameter for this manifest's endpoint URL.\n   *\n   * @default - No DRM settings\n   */\n  readonly drmSettings?: DrmSettingsKey[];\n}\n\n/**\n * Options for configuring a StartTag.\n */\nexport interface StartTagOptions {\n  /**\n   * Specify the value for PRECISE within your EXT-X-START tag.\n   *\n   * Leave blank, or choose false, to use the default value NO. Choose true to use the value YES.\n   *\n   * @default false\n   */\n  readonly precise?: boolean;\n}\n\n/**\n * Helper class for creating EXT-X-START tags in HLS playlists.\n *\n * The EXT-X-START tag indicates a preferred point at which to start playing a playlist.\n */\nexport class StartTag {\n  /**\n   * Create a start tag with a time offset.\n   *\n   * @param timeOffset The time offset in seconds. Can be positive (forward from start) or negative (back from live edge).\n   *   - If positive: must be less than (manifest duration - 3 × segment duration)\n   *   - If negative: absolute value must be greater than (3 × segment duration) and less than manifest duration\n   * @param options Additional options\n   */\n  public static of(timeOffset: number, options?: StartTagOptions): StartTag {\n    return {\n      timeOffset,\n      precise: options && options.precise !== undefined ? options.precise : undefined,\n    };\n  }\n\n  /**\n   * Create a start tag with precise positioning enabled (PRECISE=YES).\n   *\n   * @param timeOffset The time offset in seconds (positive or negative)\n   */\n  public static withPrecise(timeOffset: number): StartTag {\n    return {\n      timeOffset,\n      precise: true,\n    };\n  }\n}\n\n/**\n * Configuration for EXT-X-START tag in HLS playlists.\n *\n * Use the `StartTag` helper class to create instances with validation.\n */\nexport interface StartTag {\n  /**\n   * Specify the value for PRECISE within your EXT-X-START tag.\n   *\n   * Leave blank, or choose false, to use the default value NO. Choose true to use the value YES.\n   */\n  readonly precise?: boolean;\n  /**\n   * Specify the value for TIME-OFFSET within your EXT-X-START tag.\n   *\n   * Enter a signed floating point value which, if positive, must be less than the configured\n   * manifest duration minus three times the configured segment target duration. If negative,\n   * the absolute value must be larger than three times the configured segment target duration,\n   * and the absolute value must be smaller than the configured manifest duration.\n   */\n  readonly timeOffset: number;\n}\n\n/**\n * Base manifest configuration.\n */\ninterface ManifestConfigurationBase {\n  /**\n   * Filter configuration includes settings for manifest filtering, start and end times, and time delay that apply to all of your egress requests for this manifest.\n   *\n   * https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html\n   * @default - No filter configuration\n   */\n  readonly filterConfiguration?: FilterConfiguration;\n  /**\n   * The total duration (in seconds) of the manifest's content.\n   *\n   * @default 60\n   */\n  readonly manifestWindow?: Duration;\n}\n\n/**\n * Choose how ad markers are included in the packaged content.\n */\nexport enum AdMarkerDash {\n  /**\n   * Option for BINARY - The SCTE-35 marker is expressed as a hex-string (Base64 string) rather than full XML.\n   */\n  BINARY='BINARY',\n  /**\n   * Option for XML - The SCTE marker is expressed fully in XML.\n   */\n  XML='XML',\n}\n\n/**\n * Choose how SCTE-35 ad markers are included in HLS and LL-HLS manifests.\n */\nexport enum AdMarkerHls {\n  /**\n   * Insert EXT-X-DATERANGE tags to signal ad content.\n   */\n  DATERANGE = 'DATERANGE',\n  /**\n   * Insert enhanced SCTE-35 tags for ad content.\n   */\n  SCTE35_ENHANCED = 'SCTE35_ENHANCED',\n}\n\n/**\n * The type of variable that MediaPackage uses in the media attribute of the SegmentTemplate tag.\n */\nexport enum SegmentTemplateFormat {\n  /**\n   * Option for number with timeline.\n   */\n  NUMBER_WITH_TIMELINE='NUMBER_WITH_TIMELINE',\n}\n\n/**\n * The UTC timing mode for DASH.\n */\nexport enum DashUtcTimingMode {\n  /**\n   * Option for HTTP_HEAD.\n   */\n  HTTP_HEAD='HTTP_HEAD',\n  /**\n   * Option for HTTP_ISO.\n   */\n  HTTP_ISO='HTTP_ISO',\n  /**\n   * Option for HTTP_XSDATE.\n   */\n  HTTP_XSDATE='HTTP_XSDATE',\n  /**\n   * Option for UTC_DIRECT.\n   */\n  UTC_DIRECT='UTC_DIRECT',\n}\n\n/**\n * Options for triggers which cause AWS Elemental MediaPackage to create media presentation description (MPD) periods in the output manifest.\n */\nexport enum DashPeriodTriggers {\n  /**\n   * Option for AVAILS.\n   */\n  AVAILS='AVAILS',\n  /**\n   * Option for DRM_KEY_ROTATION.\n   */\n  DRM_KEY_ROTATION='DRM_KEY_ROTATION',\n  /**\n   * Option for SOURCE_CHANGES.\n   */\n  SOURCE_CHANGES='SOURCE_CHANGES',\n  /**\n   * Option for SOURCE_DISRUPTIONS.\n   */\n  SOURCE_DISRUPTIONS='SOURCE_DISRUPTIONS',\n  /**\n   * Option for NONE.\n   */\n  NONE='NONE',\n}\n\n/**\n * DRM signaling determines the way DASH manifest signals the DRM content.\n */\nexport enum DrmSignalling {\n  /**\n   * Option for INDIVIDUAL.\n   */\n  INDIVIDUAL='INDIVIDUAL',\n  /**\n   * Option for REFERENCED.\n   */\n  REFERENCED='REFERENCED',\n}\n\n/**\n * STANDARD indicates a default manifest, which is compacted. NONE indicates a full manifest.\n */\nexport enum DashManifestCompactness {\n  /**\n   * STANDARD\n   */\n  STANDARD='STANDARD',\n  /**\n   * NONE\n   */\n  NONE='NONE',\n}\n\n/**\n * The base URLs to use for retrieving segments. You can specify multiple locations and indicate the\n * priority and weight for when each should be used, for use in multi-CDN workflows.\n */\nexport interface DashBaseUrlProperty {\n  /**\n   * For use with DVB-DASH profiles only. The priority of this location for serving segments. The lower the number, the higher the priority.\n   *\n   * @default - No priority specified\n   */\n  readonly dvbPriority?: number;\n  /**\n   * For use with DVB-DASH profiles only. The weighting for source locations that have the same priority.\n   *\n   * @default - No weight specified\n   */\n  readonly dvbWeight?: number;\n  /**\n   * The name of the source location.\n   *\n   * @default - No service location specified\n   */\n  readonly serviceLocation?: string;\n  /**\n   * A source location for segments.\n   */\n  readonly url: string;\n}\n\n/**\n * For use with DVB-DASH profiles only. The settings for error reporting from the playback device\n * that you want AWS Elemental MediaPackage to pass through to the manifest.\n */\nexport interface DashDvbMetricsReporting {\n  /**\n   * The number of playback devices per 1000 that will send error reports to the reporting URL.\n   * This represents the probability that a playback device will be a reporting player for this session.\n   *\n   * @default - No probability specified\n   */\n  readonly probability?: number;\n  /**\n   * The URL where playback devices send error reports.\n   */\n  readonly reportingUrl: string;\n}\n\n/**\n * For use with DVB-DASH profiles only. The settings for font downloads that you want AWS Elemental MediaPackage to pass through to the manifest.\n */\nexport interface DashDvbFontDownload {\n  /**\n   * The fontFamily name for subtitles, as described in EBU-TT-D Subtitling Distribution Format.\n   * @external https://tech.ebu.ch/publications/tech3380\n   *\n   * @default - No font family specified\n   */\n  readonly fontFamily?: string;\n  /**\n   * The mimeType of the resource that's at the font download URL.\n   * For information about font MIME types, see the MPEG-DASH Profile for Transport of ISO BMFF Based DVB Services over IP Based Networks document.\n   *\n   * @external https://dvb.org/wp-content/uploads/2021/06/A168r4_MPEG-DASH-Profile-for-Transport-of-ISO-BMFF-Based-DVB-Services_Draft-ts_103-285-v140_November_2021.pdf\n   * @default - No MIME type specified\n   */\n  readonly mimeType?: string;\n  /**\n   * The URL for downloading fonts for subtitles.\n   *\n   * @default - No font download URL specified\n   */\n  readonly url?: string;\n}\n\n/**\n * The font download and error reporting information that you want MediaPackage to pass through to the manifest.\n */\nexport interface DashDvbSettings {\n  /**\n   * Playback device error reporting settings.\n   *\n   * @default - No error metrics configured\n   */\n  readonly errorMetrics?: DashDvbMetricsReporting[];\n  /**\n   * Subtitle font settings.\n   *\n   * @default - No font download configured\n   */\n  readonly fontDownload?: DashDvbFontDownload;\n}\n\n/**\n * Details about the content that you want MediaPackage to pass through in the manifest to the playback device.\n */\nexport interface DashProgramInformation {\n  /**\n   * A copyright statement about the content.\n   *\n   * @default - No copyright information\n   */\n  readonly copyright?: string;\n  /**\n   * The language code for this manifest.\n   *\n   * @default - No language code specified\n   */\n  readonly languageCode?: string;\n  /**\n   * An absolute URL that contains more information about this content.\n   *\n   * @default - No additional information URL\n   */\n  readonly moreInformationUrl?: string;\n  /**\n   * Information about the content provider.\n   *\n   * @default - No source information\n   */\n  readonly source?: string;\n  /**\n   * The title for the manifest.\n   *\n   * @default - No title specified\n   */\n  readonly title?: string;\n}\n\n/**\n * Options for TTML Profile\n */\nexport enum TtmlProfile {\n  /**\n   * IMSC_1\n   */\n  IMSC_1='IMSC_1',\n  /**\n   * EBU_TT_D_101\n   */\n  EBU_TT_D_101='EBU_TT_D_101',\n}\n/**\n * Configuration for TTML subtitles in DASH manifests.\n */\nexport interface DashTtmlConfiguration {\n  /**\n   * The profile that MediaPackage uses when signaling subtitles in the manifest. IMSC is the default profile. EBU-TT-D produces subtitles that are compliant with the EBU-TT-D TTML profile. MediaPackage passes through subtitle styles to the manifest.\n   * For more information about EBU-TT-D subtitles, see EBU-TT-D Subtitling Distribution Format.\n   *\n   * @external https://tech.ebu.ch/publications/tech3380\n   */\n  readonly ttmlProfile: TtmlProfile;\n\n}\n/**\n * Configuration for subtitles in DASH manifests.\n */\nexport interface DashSubtitleConfiguration {\n  /**\n   * Settings for TTML subtitles.\n   *\n   * @default - No TTML configuration\n   */\n  readonly ttmlConfiguration?: DashTtmlConfiguration;\n}\n\n/**\n * The layout of the MSS manifest.\n */\nexport enum MssManifestLayout {\n  /**\n   * Full manifest layout.\n   */\n  FULL = 'FULL',\n  /**\n   * Compact manifest layout.\n   */\n  COMPACT = 'COMPACT',\n}\n\n/**\n * The MSS manifest configuration associated with the origin endpoint.\n */\nexport interface MssManifestConfiguration extends ManifestConfigurationBase {\n  /**\n   * The name of the manifest associated with the MSS manifest configuration.\n   */\n  readonly manifestName: string;\n  /**\n   * The layout of the MSS manifest.\n   *\n   * @default MssManifestLayout.FULL\n   */\n  readonly manifestLayout?: MssManifestLayout;\n}\n\n/**\n * The DASH manifest configuration associated with the origin endpoint.\n */\nexport interface DashManifestConfiguration extends ManifestConfigurationBase {\n  /**\n   * The base URLs to use for retrieving segments.\n   *\n   * @default - No base URLs specified\n   */\n  readonly baseUrls?: DashBaseUrlProperty[];\n  /**\n   * The layout of the DASH manifest that MediaPackage produces.\n   *\n   * @default DashManifestCompactness.STANDARD\n   */\n  readonly compactness?: DashManifestCompactness;\n  /**\n   * For endpoints that use the DVB-DASH profile only.\n   *\n   * @default - No DVB settings\n   */\n  readonly dvbSettings?: DashDvbSettings;\n  /**\n   * The profile that the output is compliant with.\n   *\n   * @default - No profiles specified\n   */\n  readonly profiles?: string[];\n  /**\n   * Details about the content that you want MediaPackage to pass through in the manifest to the playback device.\n   *\n   * @default - No program information\n   */\n  readonly programInformation?: DashProgramInformation;\n  /**\n   * The configuration for DASH subtitles.\n   *\n   * @default - No subtitle configuration\n   */\n  readonly subtitleConfiguration?: DashSubtitleConfiguration;\n  /**\n   * The name of the manifest associated with the DASH manifest configuration.\n   */\n  readonly manifestName: string;\n  /**\n   * DRM signaling determines the way DASH manifest signals the DRM content.\n   *\n   * @default - No DRM signaling specified\n   */\n  readonly drmSignalling?: DrmSignalling;\n  /**\n   * The minimum amount of content that the player must keep available in the buffer.\n   *\n   * @default 5\n   */\n  readonly minBufferTime?: Duration;\n  /**\n   * The minimum amount of time for the player to wait before requesting an updated manifest.\n   *\n   * @default 2\n   */\n  readonly minUpdatePeriod?: Duration;\n  /**\n   * Specify what triggers cause AWS Elemental MediaPackage to create media presentation description (MPD) periods in the output manifest.\n   *\n   * @default [DashPeriodTriggers.AVAILS, DashPeriodTriggers.DRM_KEY_ROTATION, DashPeriodTriggers.SOURCE_CHANGES, DashPeriodTriggers.SOURCE_DISRUPTIONS]\n   */\n  readonly periodTriggers?: DashPeriodTriggers[];\n  /**\n   * Choose how ad markers are included in the packaged content. If you include ad markers in the content stream in your upstream encoders,\n   * then you need to inform MediaPackage what to do with the ad markers in the output.\n   *\n   * To choose this option STCE filtering needs to be enabled.\n   *\n   * @default AdMarkerDash.XML\n   */\n  readonly scteDashAdMarker?: AdMarkerDash;\n  /**\n   * The type of variable that MediaPackage uses in the media attribute of the SegmentTemplate tag.\n   *\n   * @default SegmentTemplateFormat.NUMBER_WITH_TIMELINE\n   */\n  readonly segmentTemplateFormat?: SegmentTemplateFormat;\n  /**\n   * The amount of time that the player should be from the end of the manifest.\n   *\n   * @default 10\n   */\n  readonly suggestedPresentationDelay?: Duration;\n  /**\n   * The UTC timing mode.\n   *\n   * @default DashUtcTimingMode.UTC_DIRECT\n   */\n  readonly utcTimingMode?: DashUtcTimingMode;\n  /**\n   * The method that the player uses to synchronize to coordinated universal time (UTC) wall clock time.\n   *\n   * @default undefined - No value is specified\n   */\n  readonly utcTimingSource?: string;\n}\n\n/**\n * The HLS manifest configuration associated with the origin endpoint.\n */\nexport interface HlsManifestConfiguration extends ManifestConfigurationBase {\n  /**\n   * The name of the manifest associated with the HLS manifest configuration.\n   */\n  readonly manifestName: string;\n  /**\n   * The name of the child manifest associated with the HLS manifest configuration.\n   *\n   * @default - No child manifest name specified\n   */\n  readonly childManifestName?: string;\n  /**\n   * Inserts EXT-X-PROGRAM-DATE-TIME tags in the output manifest at the interval that you specify.\n   * If you don't enter an interval, EXT-X-PROGRAM-DATE-TIME tags aren't included in the manifest.\n   * The tags sync the stream to the wall clock so that viewers can seek to a specific time in the playback timeline on the player.\n   *\n   * @default - No program date time interval\n   */\n  readonly programDateTimeInterval?: Duration;\n  /**\n   * The SCTE-35 HLS configuration associated with the HLS manifest configuration of the origin endpoint.\n   *\n   * @default - No SCTE ad marker configuration\n   */\n  readonly scteAdMarkerHls?: AdMarkerHls;\n  /**\n   * Insert EXT-X-START tag in the manifest with the configured settings\n   *\n   * @default - No start tag\n   */\n  readonly startTag?: StartTag;\n  /**\n   * When enabled, MediaPackage URL-encodes the query string for API requests for HLS child manifests to comply with AWS Signature Version 4 (SigV4) signature signing protocol.\n   * For more information, see AWS Signature Version 4 for API requests in AWS Identity and Access Management User Guide.\n   *\n   * @external https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html\n   * @default false\n   */\n  readonly urlEncodeChildManifest?: boolean;\n}\n\n/**\n * Specify a low-latency HTTP live streaming (LL-HLS) manifest configuration.\n */\nexport interface LowLatencyHlsManifestConfiguration extends ManifestConfigurationBase {\n  /**\n   * A short string that's appended to the endpoint URL. The manifest name creates a unique path to this endpoint.\n   * If you don't enter a value, MediaPackage uses the default manifest name, index. MediaPackage automatically inserts the format extension, such as .m3u8.\n   * You can't use the same manifest name if you use HLS manifest and low-latency HLS manifest.\n   * The manifestName on the HLSManifest object overrides the manifestName you provided on the originEndpoint object.\n   */\n  readonly manifestName: string;\n  /**\n   * The name of the child manifest associated with the low-latency HLS (LL-HLS) manifest configuration of the origin endpoint.\n   *\n   * @default - No child manifest name specified\n   */\n  readonly childManifestName?: string;\n  /**\n   * Inserts EXT-X-PROGRAM-DATE-TIME tags in the output manifest at the interval that you specify.\n   * If you don't enter an interval, EXT-X-PROGRAM-DATE-TIME tags aren't included in the manifest.\n   * The tags sync the stream to the wall clock so that viewers can seek to a specific time in the playback timeline on the player.\n   *\n   * @default - No program date time interval\n   */\n  readonly programDateTimeInterval?: Duration;\n  /**\n   * The SCTE-35 HLS configuration associated with the low-latency HLS (LL-HLS) manifest configuration of the origin endpoint.\n   *\n   * @default - No SCTE ad marker configuration\n   */\n  readonly scteAdMarkerHls?: AdMarkerHls;\n  /**\n   * Insert EXT-X-START tag in the manifest with the configured settings\n   *\n   * @default - No start tag\n   */\n  readonly startTag?: StartTag;\n  /**\n   * When enabled, MediaPackage URL-encodes the query string for API requests for LL-HLS child manifests to comply with AWS Signature Version 4 (SigV4) signature signing protocol.\n   * For more information, see AWS Signature Version 4 for API requests in AWS Identity and Access Management User Guide.\n   *\n   * @external https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html\n   * @default false\n   */\n  readonly urlEncodeChildManifest?: boolean;\n}\n\n/**\n * Configuration parameters for an AWS Elemental MediaPackage V2 Origin Endpoint.\n */\nexport interface OriginEndpointOptions {\n  /**\n   * The name of the origin endpoint associated with the origin endpoint configuration.\n   * @default autogenerated\n   */\n  readonly originEndpointName?: string;\n\n  /**\n   * The description associated with the origin endpoint.\n   *\n   * @default undefined - No description is added to Origin Endpoint\n   */\n  readonly description?: string;\n\n  /**\n   * The tags associated with the origin endpoint.\n   *\n   * @default - No tagging\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * Manifests configuration for HLS, Low Latency HLS and DASH.\n   */\n  readonly manifests: Manifest[];\n\n  /**\n   * The size of the window to specify a window of the live stream that's available for on-demand viewing. Viewers can start-over or catch-up on content that falls within the window.\n   *\n   * @default 900\n   */\n  readonly startoverWindow?: Duration;\n\n  /**\n   * The segment associated with the origin endpoint.\n   *\n   * Inside the segment configuration you can define options such as encryption, SPEKE parameters and other\n   * general segment configurations.\n   *\n   * Use Segment.ts() or Segment.cmaf() to create the configuration.\n   */\n  readonly segment: SegmentConfiguration;\n\n  /**\n   * The failover settings for the endpoint.\n   *\n   * @default undefined - No force endpoint configuration is configured\n   */\n  readonly forceEndpointConfigurationConditions?: EndpointErrorConfiguration[];\n\n  /**\n   * Provide access to MediaPackage V2 Origin Endpoint via secret header.\n   *\n   * @default undefined - Not configured on endpoint\n   */\n  readonly cdnAuth?: CdnAuthConfiguration;\n\n  /**\n   * Policy to apply when the origin endpoint is removed from the stack\n   *\n   * Even though MediaPackage ChannelGroups, Channels and OriginEndpoints are technically stateful,\n   * their contents are transient and it is common to add and remove these while rearchitecting your application.\n   * The default is therefore `DESTROY`. Change it to `RETAIN` if the content (in a lookback window) are so\n   * valuable that accidentally losing it would be unacceptable.\n   *\n   * @default RemovalPolicy.DESTROY\n   */\n  readonly removalPolicy?: RemovalPolicy;\n}\n\n/**\n * Properties to set on an Origin Endpoint.\n */\nexport interface OriginEndpointProps extends OriginEndpointOptions {\n  /**\n   * The channel associated with the origin endpoint.\n   */\n  readonly channel: IChannel;\n}\n\n/**\n * Represents an Origin Endpoint defined outside of this stack.\n */\nexport interface OriginEndpointAttributes {\n  /**\n   * The name that describes the channel group. The name is the primary identifier for the channel group.\n   *\n   * @attribute\n   */\n  readonly channelGroupName: string;\n\n  /**\n   * The name that describes the channel. The name is the primary identifier for the channel.\n   *\n   * @attribute\n   */\n  readonly channelName: string;\n\n  /**\n   * The name that describes the origin endpoint.\n   *\n   * @attribute\n   */\n  readonly originEndpointName: string;\n}\n\n/**\n * DRM systems available for CMAF encryption.\n *\n * CENC supports PlayReady, Widevine, and Irdeto.\n * CBCS supports PlayReady, Widevine, and FairPlay.\n */\nexport enum CmafDrmSystem {\n  /**\n   * FairPlay DRM - used with CBCS encryption.\n   */\n  FAIRPLAY = 'FAIRPLAY',\n  /**\n   * PlayReady DRM - used with CENC and CBCS encryption.\n   */\n  PLAYREADY = 'PLAYREADY',\n  /**\n   * Widevine DRM - used with CENC and CBCS encryption.\n   */\n  WIDEVINE = 'WIDEVINE',\n  /**\n   * Irdeto DRM - used with CENC encryption.\n   */\n  IRDETO = 'IRDETO',\n}\n\n/**\n * DRM systems available for TS encryption.\n *\n * SAMPLE_AES uses FairPlay, AES_128 uses Clear Key AES 128.\n */\nexport enum TsDrmSystem {\n  /**\n   * FairPlay DRM - used with SAMPLE_AES encryption.\n   */\n  FAIRPLAY = 'FAIRPLAY',\n  /**\n   * Clear Key AES 128 - used with AES_128 encryption.\n   */\n  CLEAR_KEY_AES_128 = 'CLEAR_KEY_AES_128',\n}\n\n/**\n * DRM systems available for ISM encryption.\n *\n * ISM only supports PlayReady with CENC.\n */\nexport enum IsmDrmSystem {\n  /**\n   * PlayReady DRM.\n   */\n  PLAYREADY = 'PLAYREADY',\n}\n\n/**\n * Base properties common to all SPEKE encryption configurations.\n */\ninterface SpekeEncryptionPropsBase {\n  /**\n   * The unique identifier for the content.\n   *\n   * The service sends this identifier to the key server to identify the current endpoint.\n   * How unique you make this identifier depends on how fine-grained you want access controls to be.\n   * The service does not permit you to use the same ID for two simultaneous encryption processes.\n   */\n  readonly resourceId: string;\n\n  /**\n   * IAM role for accessing the key provider API.\n   *\n   * This role must have a trust policy that allows MediaPackage to assume the role,\n   * and it must have sufficient permissions to access the key retrieval URL.\n   */\n  readonly role: IRole;\n\n  /**\n   * URL of the SPEKE key provider.\n   */\n  readonly url: string;\n\n  /**\n   * The ARN of the certificate that you imported to AWS Certificate Manager\n   * to add content key encryption to this endpoint.\n   *\n   * For this feature to work, your DRM key provider must support content key encryption.\n   *\n   * @default - no content key encryption\n   */\n  readonly certificate?: ICertificate;\n\n  /**\n   * Audio encryption preset.\n   *\n   * @default PresetSpeke20Audio.PRESET_AUDIO_1\n   */\n  readonly audioPreset?: PresetSpeke20Audio;\n\n  /**\n   * Video encryption preset.\n   *\n   * @default PresetSpeke20Video.PRESET_VIDEO_1\n   */\n  readonly videoPreset?: PresetSpeke20Video;\n}\n\n/**\n * Properties for CMAF SPEKE encryption configuration.\n */\nexport interface CmafSpekeEncryptionProps extends SpekeEncryptionPropsBase {\n  /**\n   * The encryption method to use.\n   */\n  readonly method: CmafEncryptionMethod;\n\n  /**\n   * The DRM systems to use for content protection.\n   *\n   * CENC supports PlayReady, Widevine, and Irdeto.\n   * CBCS supports PlayReady, Widevine, and FairPlay.\n   */\n  readonly drmSystems: CmafDrmSystem[];\n\n  /**\n   * Constant initialization vector (32-character hex string).\n   *\n   * A 128-bit, 16-byte hex value represented by a 32-character string,\n   * used in conjunction with the key for encrypting content.\n   *\n   * @default - MediaPackage generates the IV\n   */\n  readonly constantInitializationVector?: string;\n\n  /**\n   * Key rotation interval.\n   *\n   * @default - no rotation\n   */\n  readonly keyRotationInterval?: Duration;\n\n  /**\n   * When enabled, DRM metadata is excluded from CMAF segments.\n   *\n   * @default false\n   */\n  readonly excludeSegmentDrmMetadata?: boolean;\n}\n\n/**\n * Properties for TS SPEKE encryption configuration.\n */\nexport interface TsSpekeEncryptionProps extends SpekeEncryptionPropsBase {\n  /**\n   * The encryption method to use.\n   */\n  readonly method: TsEncryptionMethod;\n\n  /**\n   * The DRM systems to use for content protection.\n   *\n   * @default - FairPlay for SAMPLE_AES, Clear Key AES 128 for AES_128\n   */\n  readonly drmSystems?: TsDrmSystem[];\n\n  /**\n   * Constant initialization vector (32-character hex string).\n   *\n   * A 128-bit, 16-byte hex value represented by a 32-character string,\n   * used in conjunction with the key for encrypting content.\n   *\n   * @default - MediaPackage generates the IV\n   */\n  readonly constantInitializationVector?: string;\n\n  /**\n   * Key rotation interval.\n   *\n   * @default - no rotation\n   */\n  readonly keyRotationInterval?: Duration;\n}\n\n/**\n * Properties for ISM SPEKE encryption configuration.\n *\n * ISM only supports CENC encryption with PlayReady DRM.\n * Key rotation and constant initialization vectors are not supported.\n * Audio and video presets default to SHARED.\n */\nexport interface IsmSpekeEncryptionProps {\n  /**\n   * The DRM systems to use for content protection.\n   *\n   * @default - [IsmDrmSystem.PLAYREADY]\n   */\n  readonly drmSystems?: IsmDrmSystem[];\n\n  /**\n   * The unique identifier for the content.\n   */\n  readonly resourceId: string;\n\n  /**\n   * IAM role for accessing the key provider API.\n   */\n  readonly role: IRole;\n\n  /**\n   * URL of the SPEKE key provider.\n   */\n  readonly url: string;\n\n  /**\n   * The ARN of the certificate that you imported to AWS Certificate Manager\n   * to add content key encryption to this endpoint.\n   *\n   * @default - no content key encryption\n   */\n  readonly certificate?: ICertificate;\n}\n\n/**\n * Base class for encryption configurations.\n *\n * Use `CmafEncryption.speke()`, `TsEncryption.speke()`, or `IsmEncryption.speke()` to create instances.\n */\nexport abstract class EncryptionConfiguration {\n  /**\n   * Binds the encryption configuration to produce the CloudFormation property.\n   *\n   * This is an internal method used by the construct library and should not be\n   * called or implemented by external consumers. It may change without notice.\n   *\n   * @internal\n   */\n  public abstract _bind(scope: Construct): CfnOriginEndpoint.EncryptionProperty;\n\n  /**\n   * Returns the IAM role used for encryption, if any.\n   *\n   * This is an internal method used by the construct library and should not be\n   * called or implemented by external consumers. It may change without notice.\n   *\n   * @internal\n   */\n  public abstract _getRole(): IRole | undefined;\n\n  /**\n   * Returns the ACM certificate used for content key encryption, if any.\n   *\n   * This is an internal method used by the construct library and should not be\n   * called or implemented by external consumers. It may change without notice.\n   *\n   * @internal\n   */\n  public abstract _getCertificate(): ICertificate | undefined;\n}\n\n/**\n * Encryption configuration for CMAF segments.\n *\n * Use `CmafEncryption.speke()` to create an instance.\n */\nexport class CmafEncryption extends EncryptionConfiguration {\n  /**\n   * Create a SPEKE-based encryption configuration for CMAF segments.\n   */\n  public static speke(props: CmafSpekeEncryptionProps): CmafEncryption {\n    if (!props.url.startsWith('https://')) {\n      throw new UnscopedValidationError(lit`SpekeUrlHttpsRequired`, 'SPEKE key provider URL must use HTTPS.');\n    }\n    if (props.method === CmafEncryptionMethod.CENC && props.drmSystems.includes(CmafDrmSystem.FAIRPLAY)) {\n      throw new UnscopedValidationError(lit`CencFairPlayIncompatible`, 'CENC encryption method does not support FairPlay. Use CBCS for FairPlay.');\n    }\n    if (props.method === CmafEncryptionMethod.CBCS && props.drmSystems.includes(CmafDrmSystem.IRDETO)) {\n      throw new UnscopedValidationError(lit`CbcsIrdetoIncompatible`, 'CBCS encryption method does not support Irdeto. Use CENC for Irdeto.');\n    }\n    return new CmafEncryption(props);\n  }\n\n  private readonly config: CmafSpekeEncryptionProps;\n  private constructor(props: CmafSpekeEncryptionProps) {\n    super();\n    this.config = props;\n  }\n\n  /** @internal */\n  public _bind(scope: Construct): CfnOriginEndpoint.EncryptionProperty {\n    const p = this.config;\n    if (p.constantInitializationVector && p.constantInitializationVector.length !== 32) {\n      throw new ValidationError(lit`ConstantInitVectorLength`, 'Constant Initialization Vector needs to be 32 characters in length.', scope);\n    }\n    if (p.keyRotationInterval && (p.keyRotationInterval.toSeconds() < 300 || p.keyRotationInterval.toSeconds() > 31536000)) {\n      throw new ValidationError(lit`KeyRotationIntervalRange`, 'Key Rotation Interval needs to be between 300-31536000 seconds.', scope);\n    }\n    return {\n      cmafExcludeSegmentDrmMetadata: p.excludeSegmentDrmMetadata,\n      constantInitializationVector: p.constantInitializationVector,\n      keyRotationIntervalSeconds: p.keyRotationInterval?.toSeconds(),\n      encryptionMethod: { cmafEncryptionMethod: p.method },\n      spekeKeyProvider: {\n        certificateArn: p.certificate?.certificateArn,\n        drmSystems: p.drmSystems,\n        encryptionContractConfiguration: {\n          presetSpeke20Audio: p.audioPreset ?? PresetSpeke20Audio.PRESET_AUDIO_1,\n          presetSpeke20Video: p.videoPreset ?? PresetSpeke20Video.PRESET_VIDEO_1,\n        },\n        url: p.url,\n        resourceId: p.resourceId,\n        roleArn: p.role.roleArn,\n      },\n    };\n  }\n\n  /** @internal */\n  public _getRole(): IRole | undefined { return this.config.role; }\n\n  /** @internal */\n  public _getCertificate(): ICertificate | undefined { return this.config.certificate; }\n}\n\n/**\n * Encryption configuration for TS segments.\n *\n * Use `TsEncryption.speke()` to create an instance.\n */\nexport class TsEncryption extends EncryptionConfiguration {\n  /**\n   * Create a SPEKE-based encryption configuration for TS segments.\n   */\n  public static speke(props: TsSpekeEncryptionProps): TsEncryption {\n    if (!props.url.startsWith('https://')) {\n      throw new UnscopedValidationError(lit`SpekeUrlHttpsRequired`, 'SPEKE key provider URL must use HTTPS.');\n    }\n    return new TsEncryption(props);\n  }\n\n  private readonly config: TsSpekeEncryptionProps;\n  private constructor(props: TsSpekeEncryptionProps) {\n    super();\n    this.config = props;\n  }\n\n  /** @internal */\n  public _bind(scope: Construct): CfnOriginEndpoint.EncryptionProperty {\n    const p = this.config;\n    const defaultDrm: TsDrmSystem[] = p.method === TsEncryptionMethod.SAMPLE_AES\n      ? [TsDrmSystem.FAIRPLAY] : [TsDrmSystem.CLEAR_KEY_AES_128];\n    if (p.constantInitializationVector && p.constantInitializationVector.length !== 32) {\n      throw new ValidationError(lit`ConstantInitVectorLength`, 'Constant Initialization Vector needs to be 32 characters in length.', scope);\n    }\n    if (p.keyRotationInterval && (p.keyRotationInterval.toSeconds() < 300 || p.keyRotationInterval.toSeconds() > 31536000)) {\n      throw new ValidationError(lit`KeyRotationIntervalRange`, 'Key Rotation Interval needs to be between 300-31536000 seconds.', scope);\n    }\n    return {\n      constantInitializationVector: p.constantInitializationVector,\n      keyRotationIntervalSeconds: p.keyRotationInterval?.toSeconds(),\n      encryptionMethod: { tsEncryptionMethod: p.method },\n      spekeKeyProvider: {\n        certificateArn: p.certificate?.certificateArn,\n        drmSystems: (p.drmSystems ?? defaultDrm).map(d => d.toString()),\n        encryptionContractConfiguration: {\n          presetSpeke20Audio: p.audioPreset ?? PresetSpeke20Audio.PRESET_AUDIO_1,\n          presetSpeke20Video: p.videoPreset ?? PresetSpeke20Video.PRESET_VIDEO_1,\n        },\n        url: p.url,\n        resourceId: p.resourceId,\n        roleArn: p.role.roleArn,\n      },\n    };\n  }\n\n  /** @internal */\n  public _getRole(): IRole | undefined { return this.config.role; }\n\n  /** @internal */\n  public _getCertificate(): ICertificate | undefined { return this.config.certificate; }\n}\n\n/**\n * Encryption configuration for ISM (Microsoft Smooth Streaming) segments.\n *\n * ISM only supports CENC encryption with PlayReady DRM.\n * Audio and video presets are always SHARED.\n *\n * Use `IsmEncryption.speke()` to create an instance.\n */\nexport class IsmEncryption extends EncryptionConfiguration {\n  /**\n   * Create a SPEKE-based encryption configuration for ISM segments.\n   */\n  public static speke(props: IsmSpekeEncryptionProps): IsmEncryption {\n    if (!props.url.startsWith('https://')) {\n      throw new UnscopedValidationError(lit`SpekeUrlHttpsRequired`, 'SPEKE key provider URL must use HTTPS.');\n    }\n    return new IsmEncryption(props);\n  }\n\n  private readonly config: IsmSpekeEncryptionProps;\n  private constructor(props: IsmSpekeEncryptionProps) {\n    super();\n    this.config = props;\n  }\n\n  /** @internal */\n  public _bind(_scope: Construct): CfnOriginEndpoint.EncryptionProperty {\n    const p = this.config;\n    return {\n      encryptionMethod: { ismEncryptionMethod: 'CENC' },\n      spekeKeyProvider: {\n        certificateArn: p.certificate?.certificateArn,\n        drmSystems: (p.drmSystems ?? [IsmDrmSystem.PLAYREADY]).map(d => d.toString()),\n        encryptionContractConfiguration: {\n          presetSpeke20Audio: PresetSpeke20Audio.SHARED,\n          presetSpeke20Video: PresetSpeke20Video.SHARED,\n        },\n        url: p.url,\n        resourceId: p.resourceId,\n        roleArn: p.role.roleArn,\n      },\n    };\n  }\n\n  /** @internal */\n  public _getRole(): IRole | undefined { return this.config.role; }\n\n  /** @internal */\n  public _getCertificate(): ICertificate | undefined { return this.config.certificate; }\n}\n\n/**\n * The segment configuration, including the segment name, duration, and other configuration values.\n */\nexport interface SegmentConfiguration {\n  /**\n   * The container type for this segment (TS or CMAF)\n   */\n  readonly containerType: ContainerType;\n  /**\n   * Whether the segment includes I-frame-only streams.\n   *\n   * @default undefined - Not specified.\n   */\n  readonly includeIframeOnlyStreams?: boolean;\n  /**\n   * The SCTE-35 configuration associated with the segment.\n   *\n   * The SCTE-35 message types that you want to be treated as ad markers in the output.\n   *\n   * @default - No SCTE filtering\n   */\n  readonly scteFilter?: ScteMessageType[];\n  /**\n   * Controls whether SCTE-35 messages are included in segment files.\n   *\n   * @default - SCTE-35 messages are not included in segments\n   */\n  readonly scteInSegments?: ScteInSegments;\n  /**\n   * The duration of the segments.\n   *\n   * @default 6\n   */\n  readonly segmentDuration?: Duration;\n  /**\n   * The name of the segment associated with the origin endpoint.\n   *\n   * @default segment\n   */\n  readonly segmentName?: string;\n  /**\n   * Whether the segment includes DVB subtitles.\n   *\n   * @default false\n   */\n  readonly tsIncludeDvbSubtitles?: boolean;\n  /**\n   * Whether the segment is an audio rendition group.\n   *\n   * @default false\n   */\n  readonly tsUseAudioRenditionGroup?: boolean;\n  /**\n   * Encryption configuration for the segment.\n   *\n   * @default - No encryption\n   */\n  readonly encryption?: EncryptionConfiguration;\n}\n\n/**\n * Base properties common to all segment configurations.\n */\nexport interface SegmentPropsBase {\n  /**\n   * Whether to include I-frame-only streams.\n   *\n   * @default false\n   */\n  readonly includeIframeOnlyStreams?: boolean;\n\n  /**\n   * Duration of each segment.\n   *\n   * @default Duration.seconds(6)\n   */\n  readonly duration?: Duration;\n\n  /**\n   * Name of the segment.\n   *\n   * @default 'segment'\n   */\n  readonly name?: string;\n}\n\n/**\n * Properties for TS (Transport Stream) segment configuration.\n */\nexport interface TsSegmentProps extends SegmentPropsBase {\n  /**\n   * SCTE-35 message types to treat as ad markers.\n   *\n   * @default - no filtering\n   */\n  readonly scteFilter?: ScteMessageType[];\n\n  /**\n   * Controls whether SCTE-35 messages are included in segment files.\n   *\n   * @default - SCTE-35 messages are not included in segments\n   */\n  readonly scteInSegments?: ScteInSegments;\n\n  /**\n   * Whether to include DVB subtitles.\n   *\n   * @default false\n   */\n  readonly includeDvbSubtitles?: boolean;\n\n  /**\n   * Whether to use audio rendition groups.\n   *\n   * @default false\n   */\n  readonly useAudioRenditionGroup?: boolean;\n\n  /**\n   * Encryption configuration for the TS segment.\n   *\n   * Use `TsEncryption.speke()` to create the configuration.\n   *\n   * @default - No encryption\n   */\n  readonly encryption?: TsEncryption;\n}\n\n/**\n * Properties for CMAF segment configuration.\n */\nexport interface CmafSegmentProps extends SegmentPropsBase {\n  /**\n   * SCTE-35 message types to treat as ad markers.\n   *\n   * @default - no filtering\n   */\n  readonly scteFilter?: ScteMessageType[];\n\n  /**\n   * Controls whether SCTE-35 messages are included in segment files.\n   *\n   * @default - SCTE-35 messages are not included in segments\n   */\n  readonly scteInSegments?: ScteInSegments;\n\n  /**\n   * Encryption configuration for the CMAF segment.\n   *\n   * Use `CmafEncryption.speke()` to create the configuration.\n   *\n   * @default - No encryption\n   */\n  readonly encryption?: CmafEncryption;\n}\n\n/**\n * Properties for ISM (Microsoft Smooth Streaming) segment configuration.\n */\nexport interface IsmSegmentProps extends SegmentPropsBase {\n  /**\n   * Encryption configuration for the ISM segment.\n   *\n   * Use `IsmEncryption.speke()` to create the configuration.\n   *\n   * @default - No encryption\n   */\n  readonly encryption?: IsmEncryption;\n}\n\n/**\n * Helper class for creating segment configurations.\n */\nexport class Segment {\n  /**\n   * Create a TS (Transport Stream) segment configuration.\n   *\n   * Use this for endpoints with ContainerType.TS.\n   */\n  public static ts(props: TsSegmentProps = {}): SegmentConfiguration {\n    return {\n      containerType: ContainerType.TS,\n      includeIframeOnlyStreams: props.includeIframeOnlyStreams,\n      scteFilter: props.scteFilter,\n      scteInSegments: props.scteInSegments,\n      segmentDuration: props.duration,\n      segmentName: props.name,\n      tsIncludeDvbSubtitles: props.includeDvbSubtitles,\n      tsUseAudioRenditionGroup: props.useAudioRenditionGroup,\n      encryption: props.encryption,\n    };\n  }\n\n  /**\n   * Create a CMAF segment configuration.\n   *\n   * Use this for endpoints with ContainerType.CMAF.\n   */\n  public static cmaf(props: CmafSegmentProps = {}): SegmentConfiguration {\n    return {\n      containerType: ContainerType.CMAF,\n      includeIframeOnlyStreams: props.includeIframeOnlyStreams,\n      scteFilter: props.scteFilter,\n      scteInSegments: props.scteInSegments,\n      segmentDuration: props.duration,\n      segmentName: props.name,\n      encryption: props.encryption,\n    };\n  }\n\n  /**\n   * Create an ISM (Microsoft Smooth Streaming) segment configuration.\n   *\n   * Use this for endpoints with ContainerType.ISM.\n   */\n  public static ism(props: IsmSegmentProps = {}): SegmentConfiguration {\n    return {\n      containerType: ContainerType.ISM,\n      includeIframeOnlyStreams: props.includeIframeOnlyStreams,\n      segmentDuration: props.duration,\n      segmentName: props.name,\n      encryption: props.encryption,\n    };\n  }\n}\n\nabstract class OriginEndpointBase extends Resource implements IOriginEndpoint {\n  /**\n   * Creates an OriginEndpoint construct that represents an external (imported) Origin Endpoint.\n   */\n  public static fromOriginEndpointAttributes(scope: Construct, id: string, attrs: OriginEndpointAttributes): IOriginEndpoint {\n    class Import extends OriginEndpointBase implements IOriginEndpoint {\n      protected hlsManifests: CfnOriginEndpoint.HlsManifestConfigurationProperty[] = [];\n      protected llHlsManifests: CfnOriginEndpoint.LowLatencyHlsManifestConfigurationProperty[] = [];\n      protected dashManifests: CfnOriginEndpoint.DashManifestConfigurationProperty[] = [];\n      protected mssManifests: CfnOriginEndpoint.MssManifestConfigurationProperty[] = [];\n      protected segment?: SegmentConfiguration | undefined;\n      public readonly policy = undefined;\n      public readonly channelGroupName = attrs.channelGroupName;\n      public readonly channelName = attrs.channelName;\n      public readonly originEndpointName = attrs.originEndpointName;\n      public readonly createdAt = undefined;\n      public readonly modifiedAt = undefined;\n      public readonly hlsManifestUrls = undefined;\n      public readonly lowLatencyHlsManifestUrls = undefined;\n      public readonly dashManifestUrls = undefined;\n      public readonly mssManifestUrls = undefined;\n      protected autoCreatePolicy = false;\n      public readonly originEndpointArn = Stack.of(this).formatArn({\n        service: 'mediapackagev2',\n        resource: `channelGroup/${attrs.channelGroupName}/channel/${this.channelName}/originEndpoint`,\n        arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n        resourceName: this.originEndpointName,\n      });\n    }\n\n    return new Import(scope, id);\n  }\n\n  public abstract readonly channelGroupName: string;\n  public abstract readonly channelName: string;\n  public abstract readonly originEndpointName: string;\n  public abstract readonly originEndpointArn: string;\n  public abstract readonly createdAt?: string;\n  public abstract readonly modifiedAt?: string;\n  public abstract readonly hlsManifestUrls?: string[];\n  public abstract readonly lowLatencyHlsManifestUrls?: string[];\n  public abstract readonly dashManifestUrls?: string[];\n  public abstract readonly mssManifestUrls?: string[];\n\n  /**\n   * A reference to this Origin Endpoint resource.\n   * Required by the auto-generated IOriginEndpointRef interface.\n   */\n  public get originEndpointRef(): OriginEndpointReference {\n    return {\n      originEndpointArn: this.originEndpointArn,\n    };\n  }\n\n  protected abstract hlsManifests: CfnOriginEndpoint.HlsManifestConfigurationProperty[];\n  protected abstract llHlsManifests: CfnOriginEndpoint.LowLatencyHlsManifestConfigurationProperty[];\n  protected abstract dashManifests: CfnOriginEndpoint.DashManifestConfigurationProperty[];\n  protected abstract mssManifests: CfnOriginEndpoint.MssManifestConfigurationProperty[];\n  protected abstract segment?: SegmentConfiguration;\n  /**\n   * The resource policy associated with this origin endpoint.\n   *\n   * If `autoCreatePolicy` is true, an `OriginEndpointPolicy` will be created upon the\n   * first call to addToResourcePolicy(s).\n   */\n  public abstract policy?: OriginEndpointPolicy;\n\n  /**\n   * Indicates if an origin endpoint resource policy should automatically be created upon\n   * the first call to `addToResourcePolicy`.\n   */\n  protected abstract autoCreatePolicy: boolean;\n\n  /**\n   * CDN authorization configuration to be applied when the policy is created.\n   */\n  private cdnAuthConfig?: CdnAuthConfiguration;\n\n  /**\n   * Set CDN auth config. Used by subclass constructors.\n   * @internal\n   */\n  protected _setCdnAuth(cdnAuth: CdnAuthConfiguration): void {\n    if (!this.cdnAuthConfig) {\n      this.cdnAuthConfig = cdnAuth;\n    }\n  }\n\n  /**\n   * Configure origin endpoint policy.\n   *\n   * You can only add 1 OriginEndpointPolicy to an OriginEndpoint.\n   * If you have already defined one, it will append to the policy already created.\n   *\n   * @param statement - The policy statement to add\n   * @param cdnAuth - Optional CDN authorization configuration. If provided, the policy will be\n   *                  created with CDN authentication enabled using secrets from AWS Secrets Manager.\n   *                  If cdnAuth is provided multiple times, only the first configuration is used.\n   */\n  public addToResourcePolicy(statement: PolicyStatement, cdnAuth?: CdnAuthConfiguration): AddToResourcePolicyResult {\n    // Store CDN auth config if provided (only if not already set)\n    if (cdnAuth && !this.cdnAuthConfig) {\n      this.cdnAuthConfig = cdnAuth;\n    }\n\n    if (!this.policy && this.autoCreatePolicy) {\n      this.policy = new OriginEndpointPolicy(this, 'Policy', {\n        originEndpoint: this,\n        cdnAuth: this.cdnAuthConfig,\n      });\n    }\n\n    if (this.policy) {\n      this.policy.document.addStatements(statement);\n      return { statementAdded: true, policyDependable: this.policy };\n    }\n\n    return { statementAdded: false };\n  }\n\n  /**\n   * Validate and modify Segment configuration for endpoint.\n   */\n  protected segmentValidation(segmentContainerType: ContainerType, segment?: SegmentConfiguration): CfnOriginEndpoint.SegmentProperty | undefined {\n    if (segment?.segmentDuration && (segment.segmentDuration?.toSeconds() < 1 || segment.segmentDuration?.toSeconds() > 30)) {\n      throw new ValidationError(lit`SegmentDurationRange`, 'Segment Duration needs to be between 1-30 seconds.', this);\n    }\n\n    if (segmentContainerType != ContainerType.TS && (segment?.tsIncludeDvbSubtitles || segment?.tsUseAudioRenditionGroup)) {\n      throw new ValidationError(lit`TsOptionsIncompatible`, 'Disable TS Segment options for DvbSubtitles and AudioRenditionGroups when using CMAF.', this);\n    }\n\n    return {\n      includeIframeOnlyStreams: segment?.includeIframeOnlyStreams,\n      segmentDurationSeconds: segment?.segmentDuration?.toSeconds(),\n      segmentName: segment?.segmentName,\n      tsIncludeDvbSubtitles: segment?.tsIncludeDvbSubtitles,\n      tsUseAudioRenditionGroup: segment?.tsUseAudioRenditionGroup,\n      scte: (segment?.scteFilter || segment?.scteInSegments) ? {\n        scteFilter: segment?.scteFilter,\n        scteInSegments: segment?.scteInSegments,\n      } : undefined,\n      encryption: segment?.encryption?._bind(this),\n    };\n  }\n\n  /**\n   * Create a CloudWatch metric.\n   *\n   * @param metricName name of the metric.\n   * @param props metric options.\n   */\n  public metric(metricName: string, props?: MetricOptions): Metric {\n    return new Metric({\n      metricName,\n      namespace: 'AWS/MediaPackage',\n      dimensionsMap: {\n        ChannelGroup: this.channelGroupName,\n        Channel: this.channelName,\n        OriginEndpoint: this.originEndpointName,\n      },\n      ...props,\n    }).attachTo(this);\n  }\n\n  /**\n   * Returns Metric for Ingress Bytes\n   *\n   * @default - sum over 60 seconds\n   */\n  public metricIngressBytes(props?: MetricOptions): Metric {\n    return this.metric('IngressBytes', {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.BYTES,\n      ...props,\n    });\n  }\n\n  /**\n   * Returns Metric for Egress Bytes\n   *\n   * @default - sum over 60 seconds\n   */\n  public metricEgressBytes(props?: MetricOptions): Metric {\n    return this.metric('EgressBytes', {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.BYTES,\n      ...props,\n    });\n  }\n\n  /**\n   * Returns Metric for Ingress response time\n   *\n   * @default - average over 60 seconds\n   */\n  public metricIngressResponseTime(props?: MetricOptions): Metric {\n    return this.metric('IngressResponseTime', {\n      statistic: 'avg',\n      period: Duration.seconds(60),\n      unit: Unit.MILLISECONDS,\n      ...props,\n    });\n  }\n\n  /**\n   * Returns Metric for Egress Response time\n   *\n   * @default - average over 60 seconds\n   */\n  public metricEgressResponseTime(props?: MetricOptions): Metric {\n    return this.metric('EgressResponseTime', {\n      statistic: 'avg',\n      period: Duration.seconds(60),\n      unit: Unit.MILLISECONDS,\n      ...props,\n    });\n  }\n\n  /**\n   * Returns Metric for Egress Request Count\n   *\n   * @default - sum over 60 seconds\n   */\n  public metricEgressRequestCount(props?: MetricOptions): Metric {\n    return this.metric('EgressRequestCount', {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.COUNT,\n      ...props,\n    });\n  }\n\n  /**\n   * Returns Metric for Ingress Request Count\n   *\n   * @default - sum over 60 seconds\n   */\n  public metricIngressRequestCount(props?: MetricOptions): Metric {\n    return this.metric('IngressRequestCount', {\n      statistic: 'sum',\n      period: Duration.seconds(60),\n      unit: Unit.COUNT,\n      ...props,\n    });\n  }\n}\n\n/**\n * Defines an AWS Elemental MediaPackage V2 Origin Endpoint\n */\n@propertyInjectable\nexport class OriginEndpoint extends OriginEndpointBase implements IOriginEndpoint {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-mediapackagev2-alpha.OriginEndpoint';\n\n  public readonly channelGroupName: string;\n  public readonly channelName: string;\n  public readonly originEndpointName: string;\n  public readonly originEndpointArn: string;\n\n  /**\n   * The timestamp of the creation of the origin endpoint.\n   */\n  public readonly createdAt?: string;\n\n  /**\n   * The timestamp of the modification of the origin endpoint.\n   */\n  public readonly modifiedAt?: string;\n\n  /**\n   * Array containing Low Latency HLS Manifests created by the OriginEndpoint.\n   */\n  public readonly lowLatencyHlsManifestUrls?: string[];\n\n  /**\n   * Array containing HLS Manifests created by the OriginEndpoint.\n   */\n  public readonly hlsManifestUrls?: string[];\n\n  /**\n   * Array containing DASH Manifests created by the OriginEndpoint.\n   */\n  public readonly dashManifestUrls?: string[];\n  /**\n   * Array containing MSS Manifests created by the OriginEndpoint.\n   */\n  public readonly mssManifestUrls?: string[];\n  /**\n   * The resource policy associated with this origin endpoint.\n   *\n   * If `autoCreatePolicy` is true, an `OriginEndpointPolicy` will be created upon the\n   * first call to addToResourcePolicy(s).\n   */\n  public policy?: OriginEndpointPolicy;\n  protected autoCreatePolicy = true;\n  protected hlsManifests: CfnOriginEndpoint.HlsManifestConfigurationProperty[] = [];\n  protected llHlsManifests: CfnOriginEndpoint.LowLatencyHlsManifestConfigurationProperty[] = [];\n  protected dashManifests: CfnOriginEndpoint.DashManifestConfigurationProperty[] = [];\n  protected mssManifests: CfnOriginEndpoint.MssManifestConfigurationProperty[] = [];\n  protected segment?: SegmentConfiguration;\n\n  constructor(scope: Construct, id: string, props: OriginEndpointProps) {\n    super(scope, id, {\n      physicalName: props?.originEndpointName ?? Lazy.string({\n        produce: () => Names.uniqueResourceName(this, {\n          maxLength: 256,\n        }),\n      }),\n    });\n\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    // Validate originEndpointName if provided\n    if (props.originEndpointName != null && !Token.isUnresolved(props.originEndpointName)) {\n      if (props.originEndpointName.length < 1 || props.originEndpointName.length > 256) {\n        throw new ValidationError(lit`OriginEndpointNameLength`, 'Origin endpoint name must be between 1 and 256 characters in length.', this);\n      }\n      if (!props.originEndpointName.match(/^[a-zA-Z0-9_-]+$/)) {\n        throw new ValidationError(lit`OriginEndpointNamePattern`, 'Origin endpoint name must only contain alphanumeric characters, hyphens, and underscores.', this);\n      }\n    }\n\n    // Validate description if provided\n    if (props.description && !Token.isUnresolved(props.description) && props.description.length > 1024) {\n      throw new ValidationError(lit`OriginEndpointDescriptionLength`, 'Origin endpoint description must not exceed 1024 characters.', this);\n    }\n\n    this.segment = props.segment;\n\n    // Get container type from segment\n    const containerType = props.segment.containerType;\n\n    if (props?.startoverWindow && (props.startoverWindow.toSeconds() < 60 || props.startoverWindow.toSeconds() > 1209600)) {\n      throw new ValidationError(lit`StartoverWindowRange`, 'Startover Window needs to be between 60-1209600 seconds.', this);\n    }\n\n    props.manifests.forEach(manifest => {\n      manifest._bind({\n        hlsManifests: this.hlsManifests,\n        llHlsManifests: this.llHlsManifests,\n        dashManifests: this.dashManifests,\n        mssManifests: this.mssManifests,\n        segment: props.segment,\n      });\n    });\n\n    // Validate manifest and container type compatibility\n    if (this.mssManifests.length > 0 && containerType !== ContainerType.ISM) {\n      throw new ValidationError(lit`MssRequiresIsm`, 'MSS manifests require ISM container type. Use Segment.ism() for MSS manifests.', this);\n    }\n\n    if (this.dashManifests.length > 0 && containerType !== ContainerType.CMAF) {\n      throw new ValidationError(lit`DashRequiresCmaf`, 'DASH manifests require CMAF container type. Use Segment.cmaf() for DASH manifests.', this);\n    }\n\n    if ((this.hlsManifests.length > 0 || this.llHlsManifests.length > 0) && containerType === ContainerType.ISM) {\n      throw new ValidationError(lit`HlsIncompatibleWithIsm`, 'HLS and Low Latency HLS manifests are not supported with ISM container type. Use Segment.cmaf() or Segment.ts() for HLS manifests.', this);\n    }\n\n    // Validate DRM signalling requires encryption\n    if (this.dashManifests.some(m => m.drmSignaling) && !props.segment.encryption) {\n      throw new ValidationError(lit`DrmSignallingRequiresEncryption`, 'DRM signalling requires encryption to be configured on the endpoint.', this);\n    }\n\n    const origin = new CfnOriginEndpoint(this, 'Resource', {\n      channelName: props.channel.channelName,\n      channelGroupName: props.channel.channelGroupName,\n      originEndpointName: this.physicalName,\n      description: props.description,\n      tags: props?.tags ? renderTags(props.tags) : undefined,\n      hlsManifests: Lazy.any({ produce: () => this.hlsManifests }, { omitEmptyArray: true }),\n      lowLatencyHlsManifests: Lazy.any({ produce: () => this.llHlsManifests }, { omitEmptyArray: true }),\n      dashManifests: Lazy.any({ produce: () => this.dashManifests }, { omitEmptyArray: true }),\n      mssManifests: Lazy.any({ produce: () => this.mssManifests }, { omitEmptyArray: true }),\n      containerType: containerType,\n      startoverWindowSeconds: props.startoverWindow?.toSeconds(),\n      segment: this.segmentValidation(containerType, props.segment),\n      forceEndpointErrorConfiguration: props.forceEndpointConfigurationConditions ? {\n        endpointErrorConditions: props.forceEndpointConfigurationConditions,\n      }: undefined,\n    });\n\n    // The channelName/channelGroupName are rendered as literal strings (not CFN Refs), so\n    // CloudFormation cannot infer the dependency. We add direct CfnResource-level DependsOn\n    // to guarantee deploy ordering without triggering CDK's subtree-level cycle detection.\n    // For imported constructs, defaultChild is undefined (no CFN resource to order against).\n    const encryptionRole = props.segment.encryption?._getRole();\n    if (encryptionRole) origin.node.addDependency(encryptionRole);\n    const encryptionCert = props.segment.encryption?._getCertificate();\n    if (encryptionCert) origin.node.addDependency(encryptionCert);\n    const channelCfn = props.channel.node.defaultChild as CfnResource | undefined;\n    if (channelCfn && CfnResource.isCfnResource(channelCfn)) {\n      origin.addDependency(channelCfn);\n    }\n    const groupCfn = props.channel.channelGroup?.node.defaultChild as CfnResource | undefined;\n    if (groupCfn && CfnResource.isCfnResource(groupCfn)) {\n      origin.addDependency(groupCfn);\n    }\n\n    this.lowLatencyHlsManifestUrls = this.llHlsManifests.map((_, i) => Fn.select(i, origin.attrLowLatencyHlsManifestUrls));\n    this.hlsManifestUrls = this.hlsManifests.map((_, i) => Fn.select(i, origin.attrHlsManifestUrls));\n    this.dashManifestUrls = this.dashManifests.map((_, i) => Fn.select(i, origin.attrDashManifestUrls));\n    this.mssManifestUrls = this.mssManifests.map((_, i) => Fn.select(i, origin.attrMssManifestUrls));\n    this.createdAt = origin.attrCreatedAt;\n    this.modifiedAt = origin.attrModifiedAt;\n    this.channelGroupName = origin.channelGroupName;\n    this.channelName = origin.channelName;\n    this.originEndpointName = origin.originEndpointName;\n    this.originEndpointArn = origin.attrArn;\n\n    origin.applyRemovalPolicy(props?.removalPolicy ?? RemovalPolicy.DESTROY);\n\n    // Pre-set CDN auth config if provided in props\n    if (props.cdnAuth) {\n      this._setCdnAuth(props.cdnAuth);\n    }\n  }\n}\n"]}