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

package/lib/m3u8-settings.d.ts

@@ -0,0 +1,272 @@
+import type { Duration } from 'aws-cdk-lib';
+import type { FileLocation } from './file-location';
+/** Controls insertion of the Program Clock Reference (PCR) in an M3U8 container. */
+export declare class M3u8PcrControl {
+    /** Insert PCR at the configured `pcrPeriod`. */
+    static readonly CONFIGURED_PCR_PERIOD: M3u8PcrControl;
+    /** Insert a PCR for every Packetized Elementary Stream (PES) header. */
+    static readonly PCR_EVERY_PES_PACKET: M3u8PcrControl;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): M3u8PcrControl;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/** SCTE-35 passthrough behavior for an M3U8 container. */
+export declare class M3u8Scte35Behavior {
+    /** Do not pass SCTE-35 signals through. */
+    static readonly NO_PASSTHROUGH: M3u8Scte35Behavior;
+    /** Pass SCTE-35 signals from the input through to the output. */
+    static readonly PASSTHROUGH: M3u8Scte35Behavior;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): M3u8Scte35Behavior;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/** Timed-metadata passthrough behavior for an M3U8 container. */
+export declare class M3u8TimedMetadataBehavior {
+    /** Do not pass timed metadata through. */
+    static readonly NO_PASSTHROUGH: M3u8TimedMetadataBehavior;
+    /** Pass timed metadata from the input through to the output. */
+    static readonly PASSTHROUGH: M3u8TimedMetadataBehavior;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): M3u8TimedMetadataBehavior;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/** Nielsen ID3 passthrough behavior for an M3U8 container. */
+export declare class M3u8NielsenId3Behavior {
+    /** Do not insert Nielsen ID3 tags. */
+    static readonly NO_PASSTHROUGH: M3u8NielsenId3Behavior;
+    /** Nielsen inaudible tones for media tracking will be detected in the input audio and an equivalent ID3 tag will be inserted in the output. */
+    static readonly PASSTHROUGH: M3u8NielsenId3Behavior;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): M3u8NielsenId3Behavior;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/** KLV data passthrough behavior for an M3U8 container. */
+export declare class M3u8KlvBehavior {
+    /** Do not pass KLV data through. */
+    static readonly NONE: M3u8KlvBehavior;
+    /** Pass KLV data from the input through to the output. */
+    static readonly PASSTHROUGH: M3u8KlvBehavior;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): M3u8KlvBehavior;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/**
+ * Properties for M3U8 container settings.
+ *
+ * PID properties accept a decimal or hexadecimal value (and, where noted, ranges or
+ * comma-separated lists). Interval properties are `Duration` values rendered as milliseconds.
+ */
+export interface M3u8SettingsProps {
+    /**
+     * The number of audio frames to insert for each PES packet.
+     * @default - service default
+     */
+    readonly audioFramesPerPes?: number;
+    /**
+     * The PID(s) of the elementary audio streams. Accepts ranges and comma separation.
+     * @default - service default
+     */
+    readonly audioPids?: string;
+    /**
+     * KLV data passthrough behavior.
+     * @default - service default
+     */
+    readonly klvBehavior?: M3u8KlvBehavior;
+    /**
+     * The PID(s) of the KLV data streams.
+     * @default - service default
+     */
+    readonly klvDataPids?: string;
+    /**
+     * Nielsen ID3 passthrough behavior.
+     * @default - service default
+     */
+    readonly nielsenId3Behavior?: M3u8NielsenId3Behavior;
+    /**
+     * The interval between instances of the PAT in the output. A value of 0 writes the PAT once
+     * per segment file.
+     * @default - service default
+     */
+    readonly patInterval?: Duration;
+    /**
+     * Controls insertion of the Program Clock Reference (PCR).
+     * @default - service default
+     */
+    readonly pcrControl?: M3u8PcrControl;
+    /**
+     * The maximum interval between Program Clock References (PCRs).
+     * @default - service default
+     */
+    readonly pcrPeriod?: Duration;
+    /**
+     * The PID of the Program Clock Reference (PCR). Defaults to the video PID.
+     * @default - same as the video PID
+     */
+    readonly pcrPid?: string;
+    /**
+     * The interval between instances of the PMT in the output. A value of 0 writes the PMT once
+     * per segment file.
+     * @default - service default
+     */
+    readonly pmtInterval?: Duration;
+    /**
+     * The PID of the Program Map Table (PMT).
+     * @default - service default
+     */
+    readonly pmtPid?: string;
+    /**
+     * The value of the program number field in the PMT.
+     * @default - service default
+     */
+    readonly programNum?: number;
+    /**
+     * SCTE-35 passthrough behavior.
+     * @default - service default
+     */
+    readonly scte35Behavior?: M3u8Scte35Behavior;
+    /**
+     * The PID of the SCTE-35 stream.
+     * @default - service default
+     */
+    readonly scte35Pid?: string;
+    /**
+     * Timed-metadata passthrough behavior.
+     * @default - service default
+     */
+    readonly timedMetadataBehavior?: M3u8TimedMetadataBehavior;
+    /**
+     * The PID of the timed-metadata stream. Valid values are 32 (0x20)..8182 (0x1ff6).
+     * @default - service default
+     */
+    readonly timedMetadataPid?: string;
+    /**
+     * The value of the transport stream ID field in the PMT.
+     * @default - service default
+     */
+    readonly transportStreamId?: number;
+    /**
+     * The PID of the elementary video stream.
+     * @default - service default
+     */
+    readonly videoPid?: string;
+}
+/**
+ * M3U8 container settings for a standard HLS output.
+ *
+ * Use `M3u8Settings.of()` to control the transport stream produced by a standard HLS output.
+ * Omitting it uses MediaLive's service defaults.
+ */
+export declare class M3u8Settings {
+    private readonly props;
+    /** Create M3U8 container settings. */
+    static of(props: M3u8SettingsProps): M3u8Settings;
+    private constructor();
+}
+/** The audio track type for an audio-only HLS output. */
+export declare class HlsAudioTrackType {
+    /** A playable audio-only variant stream (EXT-X-STREAM-INF). */
+    static readonly AUDIO_ONLY_VARIANT_STREAM: HlsAudioTrackType;
+    /** Alternate rendition, auto-select, default (DEFAULT=YES, AUTOSELECT=YES). */
+    static readonly ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT: HlsAudioTrackType;
+    /** Alternate rendition, auto-select, not default (DEFAULT=NO, AUTOSELECT=YES). */
+    static readonly ALTERNATE_AUDIO_AUTO_SELECT: HlsAudioTrackType;
+    /** Alternate rendition, not auto-select (DEFAULT=NO, AUTOSELECT=NO). */
+    static readonly ALTERNATE_AUDIO_NOT_AUTO_SELECT: HlsAudioTrackType;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): HlsAudioTrackType;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/** The segment container type for an audio-only HLS output. */
+export declare class HlsAudioOnlySegmentType {
+    /** AAC segments. */
+    static readonly AAC: HlsAudioOnlySegmentType;
+    /** fMP4 segments. */
+    static readonly FMP4: HlsAudioOnlySegmentType;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): HlsAudioOnlySegmentType;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/** Properties for standard (video) HLS settings. */
+export interface StandardHlsSettingsProps {
+    /**
+     * The audio GROUP-IDs used with this video output stream, comma-separated.
+     * @default - service default
+     */
+    readonly audioRenditionSets?: string;
+    /**
+     * The M3U8 container settings.
+     * @default - service defaults
+     */
+    readonly m3u8Settings?: M3u8Settings;
+}
+/** Properties for audio-only HLS settings. */
+export interface AudioOnlyHlsSettingsProps {
+    /**
+     * The group that this audio rendition belongs to.
+     * @default - service default
+     */
+    readonly audioGroupId?: string;
+    /**
+     * A .jpg or .png cover-art image embedded in each audio-only segment. Provide a `FileLocation`
+     * referencing an S3 bucket (`FileLocation.fromBucket`, which auto-grants read access) or a URL
+     * (`FileLocation.url`).
+     * @default - no cover art
+     */
+    readonly audioOnlyImage?: FileLocation;
+    /**
+     * How the audio rendition is signaled in the HLS manifest.
+     * @default - service default
+     */
+    readonly audioTrackType?: HlsAudioTrackType;
+    /**
+     * The segment container type.
+     * @default - service default
+     */
+    readonly segmentType?: HlsAudioOnlySegmentType;
+}
+/** Properties for fMP4 HLS settings. */
+export interface Fmp4HlsSettingsProps {
+    /**
+     * The audio GROUP-IDs used with this video output stream, comma-separated.
+     * @default - service default
+     */
+    readonly audioRenditionSets?: string;
+    /**
+     * Nielsen ID3 passthrough behavior.
+     * @default - service default
+     */
+    readonly nielsenId3Behavior?: M3u8NielsenId3Behavior;
+    /**
+     * Timed-metadata passthrough behavior.
+     * @default - service default
+     */
+    readonly timedMetadataBehavior?: M3u8TimedMetadataBehavior;
+}
+/**
+ * Per-output HLS settings. Select the variant that matches the output: a standard (video)
+ * output, an audio-only rendition, an fMP4 output, or a frame-capture output.
+ */
+export declare abstract class HlsSettings {
+    /** Settings for a standard (video) HLS output. */
+    static standard(props?: StandardHlsSettingsProps): HlsSettings;
+    /** Settings for an audio-only HLS rendition. */
+    static audioOnly(props?: AudioOnlyHlsSettingsProps): HlsSettings;
+    /** Settings for an fMP4 HLS output. */
+    static fmp4(props?: Fmp4HlsSettingsProps): HlsSettings;
+    /** Settings for a frame-capture output in an HLS output group. */
+    static frameCapture(): HlsSettings;
+}

package/lib/m3u8-settings.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HlsSettings = exports.HlsAudioOnlySegmentType = exports.HlsAudioTrackType = exports.M3u8Settings = exports.M3u8KlvBehavior = exports.M3u8NielsenId3Behavior = exports.M3u8TimedMetadataBehavior = exports.M3u8Scte35Behavior = exports.M3u8PcrControl = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/** Controls insertion of the Program Clock Reference (PCR) in an M3U8 container. */
+class M3u8PcrControl {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.M3u8PcrControl", version: "2.268.0-alpha.0" };
+    /** Insert PCR at the configured `pcrPeriod`. */
+    static CONFIGURED_PCR_PERIOD = new M3u8PcrControl('CONFIGURED_PCR_PERIOD');
+    /** Insert a PCR for every Packetized Elementary Stream (PES) header. */
+    static PCR_EVERY_PES_PACKET = new M3u8PcrControl('PCR_EVERY_PES_PACKET');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new M3u8PcrControl(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.M3u8PcrControl = M3u8PcrControl;
+/** SCTE-35 passthrough behavior for an M3U8 container. */
+class M3u8Scte35Behavior {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.M3u8Scte35Behavior", version: "2.268.0-alpha.0" };
+    /** Do not pass SCTE-35 signals through. */
+    static NO_PASSTHROUGH = new M3u8Scte35Behavior('NO_PASSTHROUGH');
+    /** Pass SCTE-35 signals from the input through to the output. */
+    static PASSTHROUGH = new M3u8Scte35Behavior('PASSTHROUGH');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new M3u8Scte35Behavior(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.M3u8Scte35Behavior = M3u8Scte35Behavior;
+/** Timed-metadata passthrough behavior for an M3U8 container. */
+class M3u8TimedMetadataBehavior {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.M3u8TimedMetadataBehavior", version: "2.268.0-alpha.0" };
+    /** Do not pass timed metadata through. */
+    static NO_PASSTHROUGH = new M3u8TimedMetadataBehavior('NO_PASSTHROUGH');
+    /** Pass timed metadata from the input through to the output. */
+    static PASSTHROUGH = new M3u8TimedMetadataBehavior('PASSTHROUGH');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new M3u8TimedMetadataBehavior(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.M3u8TimedMetadataBehavior = M3u8TimedMetadataBehavior;
+/** Nielsen ID3 passthrough behavior for an M3U8 container. */
+class M3u8NielsenId3Behavior {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.M3u8NielsenId3Behavior", version: "2.268.0-alpha.0" };
+    /** Do not insert Nielsen ID3 tags. */
+    static NO_PASSTHROUGH = new M3u8NielsenId3Behavior('NO_PASSTHROUGH');
+    /** Nielsen inaudible tones for media tracking will be detected in the input audio and an equivalent ID3 tag will be inserted in the output. */
+    static PASSTHROUGH = new M3u8NielsenId3Behavior('PASSTHROUGH');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new M3u8NielsenId3Behavior(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.M3u8NielsenId3Behavior = M3u8NielsenId3Behavior;
+/** KLV data passthrough behavior for an M3U8 container. */
+class M3u8KlvBehavior {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.M3u8KlvBehavior", version: "2.268.0-alpha.0" };
+    /** Do not pass KLV data through. */
+    static NONE = new M3u8KlvBehavior('NONE');
+    /** Pass KLV data from the input through to the output. */
+    static PASSTHROUGH = new M3u8KlvBehavior('PASSTHROUGH');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new M3u8KlvBehavior(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.M3u8KlvBehavior = M3u8KlvBehavior;
+/**
+ * M3U8 container settings for a standard HLS output.
+ *
+ * Use `M3u8Settings.of()` to control the transport stream produced by a standard HLS output.
+ * Omitting it uses MediaLive's service defaults.
+ */
+class M3u8Settings {
+    props;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.M3u8Settings", version: "2.268.0-alpha.0" };
+    /** Create M3U8 container settings. */
+    static of(props) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_M3u8SettingsProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.of);
+            }
+            throw error;
+        }
+        return new M3u8Settings(props);
+    }
+    constructor(props) {
+        this.props = props;
+    }
+    /** @internal */
+    _bind() {
+        const p = this.props;
+        return {
+            audioFramesPerPes: p.audioFramesPerPes,
+            audioPids: p.audioPids,
+            klvBehavior: p.klvBehavior?.value,
+            klvDataPids: p.klvDataPids,
+            nielsenId3Behavior: p.nielsenId3Behavior?.value,
+            patInterval: p.patInterval?.toMilliseconds(),
+            pcrControl: p.pcrControl?.value,
+            pcrPeriod: p.pcrPeriod?.toMilliseconds(),
+            pcrPid: p.pcrPid,
+            pmtInterval: p.pmtInterval?.toMilliseconds(),
+            pmtPid: p.pmtPid,
+            programNum: p.programNum,
+            scte35Behavior: p.scte35Behavior?.value,
+            scte35Pid: p.scte35Pid,
+            timedMetadataBehavior: p.timedMetadataBehavior?.value,
+            timedMetadataPid: p.timedMetadataPid,
+            transportStreamId: p.transportStreamId,
+            videoPid: p.videoPid,
+        };
+    }
+}
+exports.M3u8Settings = M3u8Settings;
+/** The audio track type for an audio-only HLS output. */
+class HlsAudioTrackType {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.HlsAudioTrackType", version: "2.268.0-alpha.0" };
+    /** A playable audio-only variant stream (EXT-X-STREAM-INF). */
+    static AUDIO_ONLY_VARIANT_STREAM = new HlsAudioTrackType('AUDIO_ONLY_VARIANT_STREAM');
+    /** Alternate rendition, auto-select, default (DEFAULT=YES, AUTOSELECT=YES). */
+    static ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT = new HlsAudioTrackType('ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT');
+    /** Alternate rendition, auto-select, not default (DEFAULT=NO, AUTOSELECT=YES). */
+    static ALTERNATE_AUDIO_AUTO_SELECT = new HlsAudioTrackType('ALTERNATE_AUDIO_AUTO_SELECT');
+    /** Alternate rendition, not auto-select (DEFAULT=NO, AUTOSELECT=NO). */
+    static ALTERNATE_AUDIO_NOT_AUTO_SELECT = new HlsAudioTrackType('ALTERNATE_AUDIO_NOT_AUTO_SELECT');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new HlsAudioTrackType(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.HlsAudioTrackType = HlsAudioTrackType;
+/** The segment container type for an audio-only HLS output. */
+class HlsAudioOnlySegmentType {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.HlsAudioOnlySegmentType", version: "2.268.0-alpha.0" };
+    /** AAC segments. */
+    static AAC = new HlsAudioOnlySegmentType('AAC');
+    /** fMP4 segments. */
+    static FMP4 = new HlsAudioOnlySegmentType('FMP4');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new HlsAudioOnlySegmentType(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.HlsAudioOnlySegmentType = HlsAudioOnlySegmentType;
+/**
+ * Per-output HLS settings. Select the variant that matches the output: a standard (video)
+ * output, an audio-only rendition, an fMP4 output, or a frame-capture output.
+ */
+class HlsSettings {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.HlsSettings", version: "2.268.0-alpha.0" };
+    /** Settings for a standard (video) HLS output. */
+    static standard(props = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_StandardHlsSettingsProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.standard);
+            }
+            throw error;
+        }
+        return new StandardHlsSettings(props);
+    }
+    /** Settings for an audio-only HLS rendition. */
+    static audioOnly(props = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_AudioOnlyHlsSettingsProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.audioOnly);
+            }
+            throw error;
+        }
+        return new AudioOnlyHlsSettings(props);
+    }
+    /** Settings for an fMP4 HLS output. */
+    static fmp4(props = {}) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_Fmp4HlsSettingsProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.fmp4);
+            }
+            throw error;
+        }
+        return new Fmp4HlsSettings(props);
+    }
+    /** Settings for a frame-capture output in an HLS output group. */
+    static frameCapture() {
+        return new FrameCaptureHlsSettings();
+    }
+    /**
+     * Grant the channel role read access to any external files these settings reference (e.g. an
+     * audio-only cover-art image in S3). Default is a no-op; audio-only settings override it.
+     * @internal
+     */
+    _grantRead(_role) { }
+}
+exports.HlsSettings = HlsSettings;
+/** @internal */
+class StandardHlsSettings extends HlsSettings {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    _bind() {
+        return {
+            standardHlsSettings: {
+                audioRenditionSets: this.props.audioRenditionSets,
+                m3U8Settings: this.props.m3u8Settings?._bind() ?? {},
+            },
+        };
+    }
+}
+/** @internal */
+class AudioOnlyHlsSettings extends HlsSettings {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    _bind() {
+        return {
+            audioOnlyHlsSettings: {
+                audioGroupId: this.props.audioGroupId,
+                audioOnlyImage: this.props.audioOnlyImage?._bind(),
+                audioTrackType: this.props.audioTrackType?.value,
+                segmentType: this.props.segmentType?.value,
+            },
+        };
+    }
+    _grantRead(role) {
+        this.props.audioOnlyImage?._grantRead(role);
+    }
+}
+/** @internal */
+class Fmp4HlsSettings extends HlsSettings {
+    props;
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    _bind() {
+        return {
+            fmp4HlsSettings: {
+                audioRenditionSets: this.props.audioRenditionSets,
+                nielsenId3Behavior: this.props.nielsenId3Behavior?.value,
+                timedMetadataBehavior: this.props.timedMetadataBehavior?.value,
+            },
+        };
+    }
+}
+/** @internal */
+class FrameCaptureHlsSettings extends HlsSettings {
+    _bind() {
+        return { frameCaptureHlsSettings: {} };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"m3u8-settings.js","sourceRoot":"","sources":["m3u8-settings.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Duration } from 'aws-cdk-lib';\nimport type { IRole } from 'aws-cdk-lib/aws-iam';\nimport type { CfnChannel } from 'aws-cdk-lib/aws-medialive';\nimport type { FileLocation } from './file-location';\n\n/** Controls insertion of the Program Clock Reference (PCR) in an M3U8 container. */\nexport class M3u8PcrControl {\n  /** Insert PCR at the configured `pcrPeriod`. */\n  public static readonly CONFIGURED_PCR_PERIOD = new M3u8PcrControl('CONFIGURED_PCR_PERIOD');\n  /** Insert a PCR for every Packetized Elementary Stream (PES) header. */\n  public static readonly PCR_EVERY_PES_PACKET = new M3u8PcrControl('PCR_EVERY_PES_PACKET');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): M3u8PcrControl {\n    return new M3u8PcrControl(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/** SCTE-35 passthrough behavior for an M3U8 container. */\nexport class M3u8Scte35Behavior {\n  /** Do not pass SCTE-35 signals through. */\n  public static readonly NO_PASSTHROUGH = new M3u8Scte35Behavior('NO_PASSTHROUGH');\n  /** Pass SCTE-35 signals from the input through to the output. */\n  public static readonly PASSTHROUGH = new M3u8Scte35Behavior('PASSTHROUGH');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): M3u8Scte35Behavior {\n    return new M3u8Scte35Behavior(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/** Timed-metadata passthrough behavior for an M3U8 container. */\nexport class M3u8TimedMetadataBehavior {\n  /** Do not pass timed metadata through. */\n  public static readonly NO_PASSTHROUGH = new M3u8TimedMetadataBehavior('NO_PASSTHROUGH');\n  /** Pass timed metadata from the input through to the output. */\n  public static readonly PASSTHROUGH = new M3u8TimedMetadataBehavior('PASSTHROUGH');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): M3u8TimedMetadataBehavior {\n    return new M3u8TimedMetadataBehavior(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/** Nielsen ID3 passthrough behavior for an M3U8 container. */\nexport class M3u8NielsenId3Behavior {\n  /** Do not insert Nielsen ID3 tags. */\n  public static readonly NO_PASSTHROUGH = new M3u8NielsenId3Behavior('NO_PASSTHROUGH');\n  /** Nielsen inaudible tones for media tracking will be detected in the input audio and an equivalent ID3 tag will be inserted in the output. */\n  public static readonly PASSTHROUGH = new M3u8NielsenId3Behavior('PASSTHROUGH');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): M3u8NielsenId3Behavior {\n    return new M3u8NielsenId3Behavior(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/** KLV data passthrough behavior for an M3U8 container. */\nexport class M3u8KlvBehavior {\n  /** Do not pass KLV data through. */\n  public static readonly NONE = new M3u8KlvBehavior('NONE');\n  /** Pass KLV data from the input through to the output. */\n  public static readonly PASSTHROUGH = new M3u8KlvBehavior('PASSTHROUGH');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): M3u8KlvBehavior {\n    return new M3u8KlvBehavior(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/**\n * Properties for M3U8 container settings.\n *\n * PID properties accept a decimal or hexadecimal value (and, where noted, ranges or\n * comma-separated lists). Interval properties are `Duration` values rendered as milliseconds.\n */\nexport interface M3u8SettingsProps {\n  /**\n   * The number of audio frames to insert for each PES packet.\n   * @default - service default\n   */\n  readonly audioFramesPerPes?: number;\n  /**\n   * The PID(s) of the elementary audio streams. Accepts ranges and comma separation.\n   * @default - service default\n   */\n  readonly audioPids?: string;\n  /**\n   * KLV data passthrough behavior.\n   * @default - service default\n   */\n  readonly klvBehavior?: M3u8KlvBehavior;\n  /**\n   * The PID(s) of the KLV data streams.\n   * @default - service default\n   */\n  readonly klvDataPids?: string;\n  /**\n   * Nielsen ID3 passthrough behavior.\n   * @default - service default\n   */\n  readonly nielsenId3Behavior?: M3u8NielsenId3Behavior;\n  /**\n   * The interval between instances of the PAT in the output. A value of 0 writes the PAT once\n   * per segment file.\n   * @default - service default\n   */\n  readonly patInterval?: Duration;\n  /**\n   * Controls insertion of the Program Clock Reference (PCR).\n   * @default - service default\n   */\n  readonly pcrControl?: M3u8PcrControl;\n  /**\n   * The maximum interval between Program Clock References (PCRs).\n   * @default - service default\n   */\n  readonly pcrPeriod?: Duration;\n  /**\n   * The PID of the Program Clock Reference (PCR). Defaults to the video PID.\n   * @default - same as the video PID\n   */\n  readonly pcrPid?: string;\n  /**\n   * The interval between instances of the PMT in the output. A value of 0 writes the PMT once\n   * per segment file.\n   * @default - service default\n   */\n  readonly pmtInterval?: Duration;\n  /**\n   * The PID of the Program Map Table (PMT).\n   * @default - service default\n   */\n  readonly pmtPid?: string;\n  /**\n   * The value of the program number field in the PMT.\n   * @default - service default\n   */\n  readonly programNum?: number;\n  /**\n   * SCTE-35 passthrough behavior.\n   * @default - service default\n   */\n  readonly scte35Behavior?: M3u8Scte35Behavior;\n  /**\n   * The PID of the SCTE-35 stream.\n   * @default - service default\n   */\n  readonly scte35Pid?: string;\n  /**\n   * Timed-metadata passthrough behavior.\n   * @default - service default\n   */\n  readonly timedMetadataBehavior?: M3u8TimedMetadataBehavior;\n  /**\n   * The PID of the timed-metadata stream. Valid values are 32 (0x20)..8182 (0x1ff6).\n   * @default - service default\n   */\n  readonly timedMetadataPid?: string;\n  /**\n   * The value of the transport stream ID field in the PMT.\n   * @default - service default\n   */\n  readonly transportStreamId?: number;\n  /**\n   * The PID of the elementary video stream.\n   * @default - service default\n   */\n  readonly videoPid?: string;\n}\n\n/**\n * M3U8 container settings for a standard HLS output.\n *\n * Use `M3u8Settings.of()` to control the transport stream produced by a standard HLS output.\n * Omitting it uses MediaLive's service defaults.\n */\nexport class M3u8Settings {\n  /** Create M3U8 container settings. */\n  public static of(props: M3u8SettingsProps): M3u8Settings {\n    return new M3u8Settings(props);\n  }\n\n  private constructor(private readonly props: M3u8SettingsProps) {}\n\n  /** @internal */\n  public _bind(): CfnChannel.M3u8SettingsProperty {\n    const p = this.props;\n    return {\n      audioFramesPerPes: p.audioFramesPerPes,\n      audioPids: p.audioPids,\n      klvBehavior: p.klvBehavior?.value,\n      klvDataPids: p.klvDataPids,\n      nielsenId3Behavior: p.nielsenId3Behavior?.value,\n      patInterval: p.patInterval?.toMilliseconds(),\n      pcrControl: p.pcrControl?.value,\n      pcrPeriod: p.pcrPeriod?.toMilliseconds(),\n      pcrPid: p.pcrPid,\n      pmtInterval: p.pmtInterval?.toMilliseconds(),\n      pmtPid: p.pmtPid,\n      programNum: p.programNum,\n      scte35Behavior: p.scte35Behavior?.value,\n      scte35Pid: p.scte35Pid,\n      timedMetadataBehavior: p.timedMetadataBehavior?.value,\n      timedMetadataPid: p.timedMetadataPid,\n      transportStreamId: p.transportStreamId,\n      videoPid: p.videoPid,\n    };\n  }\n}\n\n/** The audio track type for an audio-only HLS output. */\nexport class HlsAudioTrackType {\n  /** A playable audio-only variant stream (EXT-X-STREAM-INF). */\n  public static readonly AUDIO_ONLY_VARIANT_STREAM = new HlsAudioTrackType('AUDIO_ONLY_VARIANT_STREAM');\n  /** Alternate rendition, auto-select, default (DEFAULT=YES, AUTOSELECT=YES). */\n  public static readonly ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT = new HlsAudioTrackType('ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT');\n  /** Alternate rendition, auto-select, not default (DEFAULT=NO, AUTOSELECT=YES). */\n  public static readonly ALTERNATE_AUDIO_AUTO_SELECT = new HlsAudioTrackType('ALTERNATE_AUDIO_AUTO_SELECT');\n  /** Alternate rendition, not auto-select (DEFAULT=NO, AUTOSELECT=NO). */\n  public static readonly ALTERNATE_AUDIO_NOT_AUTO_SELECT = new HlsAudioTrackType('ALTERNATE_AUDIO_NOT_AUTO_SELECT');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): HlsAudioTrackType {\n    return new HlsAudioTrackType(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/** The segment container type for an audio-only HLS output. */\nexport class HlsAudioOnlySegmentType {\n  /** AAC segments. */\n  public static readonly AAC = new HlsAudioOnlySegmentType('AAC');\n  /** fMP4 segments. */\n  public static readonly FMP4 = new HlsAudioOnlySegmentType('FMP4');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): HlsAudioOnlySegmentType {\n    return new HlsAudioOnlySegmentType(value);\n  }\n\n  /** The underlying string value passed to CloudFormation. */\n  public readonly value: string;\n\n  private constructor(value: string) {\n    this.value = value;\n  }\n}\n\n/** Properties for standard (video) HLS settings. */\nexport interface StandardHlsSettingsProps {\n  /**\n   * The audio GROUP-IDs used with this video output stream, comma-separated.\n   * @default - service default\n   */\n  readonly audioRenditionSets?: string;\n  /**\n   * The M3U8 container settings.\n   * @default - service defaults\n   */\n  readonly m3u8Settings?: M3u8Settings;\n}\n\n/** Properties for audio-only HLS settings. */\nexport interface AudioOnlyHlsSettingsProps {\n  /**\n   * The group that this audio rendition belongs to.\n   * @default - service default\n   */\n  readonly audioGroupId?: string;\n  /**\n   * A .jpg or .png cover-art image embedded in each audio-only segment. Provide a `FileLocation`\n   * referencing an S3 bucket (`FileLocation.fromBucket`, which auto-grants read access) or a URL\n   * (`FileLocation.url`).\n   * @default - no cover art\n   */\n  readonly audioOnlyImage?: FileLocation;\n  /**\n   * How the audio rendition is signaled in the HLS manifest.\n   * @default - service default\n   */\n  readonly audioTrackType?: HlsAudioTrackType;\n  /**\n   * The segment container type.\n   * @default - service default\n   */\n  readonly segmentType?: HlsAudioOnlySegmentType;\n}\n\n/** Properties for fMP4 HLS settings. */\nexport interface Fmp4HlsSettingsProps {\n  /**\n   * The audio GROUP-IDs used with this video output stream, comma-separated.\n   * @default - service default\n   */\n  readonly audioRenditionSets?: string;\n  /**\n   * Nielsen ID3 passthrough behavior.\n   * @default - service default\n   */\n  readonly nielsenId3Behavior?: M3u8NielsenId3Behavior;\n  /**\n   * Timed-metadata passthrough behavior.\n   * @default - service default\n   */\n  readonly timedMetadataBehavior?: M3u8TimedMetadataBehavior;\n}\n\n/**\n * Per-output HLS settings. Select the variant that matches the output: a standard (video)\n * output, an audio-only rendition, an fMP4 output, or a frame-capture output.\n */\nexport abstract class HlsSettings {\n  /** Settings for a standard (video) HLS output. */\n  public static standard(props: StandardHlsSettingsProps = {}): HlsSettings {\n    return new StandardHlsSettings(props);\n  }\n  /** Settings for an audio-only HLS rendition. */\n  public static audioOnly(props: AudioOnlyHlsSettingsProps = {}): HlsSettings {\n    return new AudioOnlyHlsSettings(props);\n  }\n  /** Settings for an fMP4 HLS output. */\n  public static fmp4(props: Fmp4HlsSettingsProps = {}): HlsSettings {\n    return new Fmp4HlsSettings(props);\n  }\n  /** Settings for a frame-capture output in an HLS output group. */\n  public static frameCapture(): HlsSettings {\n    return new FrameCaptureHlsSettings();\n  }\n\n  /** @internal */\n  public abstract _bind(): CfnChannel.HlsSettingsProperty;\n\n  /**\n   * Grant the channel role read access to any external files these settings reference (e.g. an\n   * audio-only cover-art image in S3). Default is a no-op; audio-only settings override it.\n   * @internal\n   */\n  public _grantRead(_role: IRole): void {}\n}\n\n/** @internal */\nclass StandardHlsSettings extends HlsSettings {\n  constructor(private readonly props: StandardHlsSettingsProps) { super(); }\n  public _bind(): CfnChannel.HlsSettingsProperty {\n    return {\n      standardHlsSettings: {\n        audioRenditionSets: this.props.audioRenditionSets,\n        m3U8Settings: this.props.m3u8Settings?._bind() ?? {},\n      },\n    };\n  }\n}\n\n/** @internal */\nclass AudioOnlyHlsSettings extends HlsSettings {\n  constructor(private readonly props: AudioOnlyHlsSettingsProps) { super(); }\n  public _bind(): CfnChannel.HlsSettingsProperty {\n    return {\n      audioOnlyHlsSettings: {\n        audioGroupId: this.props.audioGroupId,\n        audioOnlyImage: this.props.audioOnlyImage?._bind(),\n        audioTrackType: this.props.audioTrackType?.value,\n        segmentType: this.props.segmentType?.value,\n      },\n    };\n  }\n  public override _grantRead(role: IRole): void {\n    this.props.audioOnlyImage?._grantRead(role);\n  }\n}\n\n/** @internal */\nclass Fmp4HlsSettings extends HlsSettings {\n  constructor(private readonly props: Fmp4HlsSettingsProps) { super(); }\n  public _bind(): CfnChannel.HlsSettingsProperty {\n    return {\n      fmp4HlsSettings: {\n        audioRenditionSets: this.props.audioRenditionSets,\n        nielsenId3Behavior: this.props.nielsenId3Behavior?.value,\n        timedMetadataBehavior: this.props.timedMetadataBehavior?.value,\n      },\n    };\n  }\n}\n\n/** @internal */\nclass FrameCaptureHlsSettings extends HlsSettings {\n  public _bind(): CfnChannel.HlsSettingsProperty {\n    return { frameCaptureHlsSettings: {} };\n  }\n}\n"]}

package/lib/medialive-grants.generated.d.ts

@@ -0,0 +1,30 @@
+import * as medialive from "aws-cdk-lib/aws-medialive";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as cdk from "aws-cdk-lib/core";
+/**
+ * Collection of grant methods for a IChannelRef
+ */
+export declare class ChannelGrants {
+    /**
+     * Creates grants for ChannelGrants
+     */
+    static fromChannel(resource: medialive.IChannelRef): ChannelGrants;
+    protected readonly resource: medialive.IChannelRef;
+    private constructor();
+    /**
+     * Grant the given identity custom permissions
+     */
+    actions(grantee: iam.IGrantable, actions: Array<string>, options?: cdk.PermissionsOptions): iam.Grant;
+    /**
+     * Grant permissions to start this channel
+     */
+    start(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant permissions to stop this channel
+     */
+    stop(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant permissions to update the schedule of this channel
+     */
+    updateSchedule(grantee: iam.IGrantable): iam.Grant;
+}