# AWS::MediaPackageV2 Construct Library

> Version 2.274.0-alpha.0

> **Separate package**
>
> `@aws-cdk/aws-mediapackagev2-alpha` is not part of `aws-cdk-lib` — install it separately:
>
> ```sh
> npm install @aws-cdk/aws-mediapackagev2-alpha
> pip install aws-cdk.aws-mediapackagev2-alpha
> ```
>
> This module is [**experimental**](/stability) (alpha): its API may change in any release, without a major version bump.
---

![cdk-constructs: Experimental](https://img.shields.io/badge/cdk--constructs-experimental-important.svg?style=for-the-badge)

> The APIs of higher level constructs in this module are experimental and under active development.
> They are subject to non-backward compatible changes or removal in any future version. These are
> not subject to the [Semantic Versioning](https://semver.org/) model and breaking changes will be
> announced in the release notes. This means that while you may use them, you may need to update
> your source code when upgrading to a newer version of this package.

---

## AWS Elemental MediaPackage V2

MediaPackage delivers high-quality video without concern for capacity and makes it easier to implement popular DVR features such as start over, pause, and rewind. Your content will be protected with comprehensive support for DRM. The service seamlessly integrates with other AWS media services as a complete set of tools for cloud-based video processing and delivery.

This package contains constructs for working with AWS Elemental MediaPackage V2. Allowing you to define AWS Elemental MediaPackage V2 Channel Groups, Channels, Origin Endpoints, Channel Policies and Origin Endpoint Policies.

For further information on AWS Elemental MediaPackage V2, see [the documentation](https://aws.amazon.com/mediapackage/).

The following example creates an AWS Elemental MediaPackage V2 Channel Group, Channel and Origin Endpoint:

```ts
declare const stack: Stack;
const group = new ChannelGroup(stack, 'MyChannelGroup', {
    channelGroupName: 'my-test-channel-group',
});

const channel = new Channel(stack, 'MyChannel', {
    channelGroup: group,
    channelName: 'my-testchannel',
    input: InputConfiguration.cmaf(),
});

const endpoint = new OriginEndpoint(stack, 'MyOriginEndpoint', {
    channel,
    originEndpointName: 'my-test-endpoint',
    segment: Segment.cmaf(),
    manifests: [Manifest.hls({
        manifestName: 'index',
    })],
});
```

## Using Factory Methods

```ts
declare const stack: Stack;

// Create a channel group
const group = new ChannelGroup(stack, 'MyChannelGroup', {
  channelGroupName: 'my-channel-group',
});

// Add a channel using the factory method
const channel = group.addChannel('MyChannel', {
  channelName: 'my-channel',
  input: InputConfiguration.cmaf(),
});

// Add an origin endpoint using the factory method
const endpoint = channel.addOriginEndpoint('MyEndpoint', {
  originEndpointName: 'my-endpoint',
  segment: Segment.cmaf(),
  manifests: [Manifest.hls({ manifestName: 'index' })],
});
```

## Channel Group

A channel group is the top-level resource that consists of channels and origin endpoints associated with it.

The following code creates a Channel Group:

```ts
declare const stack: Stack;
const group = new ChannelGroup(stack, 'MyChannelGroup', {
    channelGroupName: 'my-test-channel-group',
});
```

The following code imports an existing channel group using the name attribute:

```ts
declare const stack: Stack;
const channelGroup = ChannelGroup.fromChannelGroupAttributes(stack, 'ImportedChannelGroup', {
    channelGroupName: 'MyChannelGroup',
});
```

You can also import from an ARN, which automatically extracts the name and region:

```ts
declare const stack: Stack;
const channelGroup = ChannelGroup.fromChannelGroupArn(stack, 'ImportedChannelGroup',
    'arn:aws:mediapackagev2:us-west-2:123456789012:channelGroup/MyChannelGroup',
);
```

For cross-region imports, pass the `region` parameter to ensure the correct ARN is constructed:

```ts
declare const stack: Stack;
const channelGroup = ChannelGroup.fromChannelGroupAttributes(stack, 'ImportedChannelGroup', {
    channelGroupName: 'MyChannelGroup',
    region: 'us-west-2',
});
```

## Channel

A channel is part of a channel group and represents the entry point for a content stream into MediaPackage.

### Input Configuration

Channels support two input types: HLS and CMAF.

```ts
declare const stack: Stack;
declare const group: ChannelGroup;

const hlsChannel = new Channel(stack, 'HlsChannel', {
  channelGroup: group,
  input: InputConfiguration.hls(),
});

const cmafChannel = new Channel(stack, 'CmafChannel', {
  channelGroup: group,
  input: InputConfiguration.cmaf({
    inputSwitchConfiguration: {
      mqcsInputSwitching: true,
    },
    outputHeaders: [HeadersCMSD.MQCS],
  }),
});

const simpleCmafChannel = new Channel(stack, 'SimpleCmafChannel', {
  channelGroup: group,
  input: InputConfiguration.cmaf({
    outputHeaders: [HeadersCMSD.MQCS],
  }),
});
```

### Importing an Existing Channel

The following code imports an existing channel using the name attributes:

```ts
declare const stack: Stack;
const channel = Channel.fromChannelAttributes(stack, 'ImportedChannel', {
    channelName: 'MyChannel',
    channelGroupName: 'MyChannelGroup',
});
```

You can also import from an ARN:

```ts
declare const stack: Stack;
const channel = Channel.fromChannelArn(stack, 'ImportedChannel',
    'arn:aws:mediapackagev2:us-west-2:123456789012:channelGroup/MyGroup/channel/MyChannel',
);
```

Imported channels expose a `region` property, which is parsed from the ARN or falls back to the importing stack's region.

### Channel Resource Policy

The following code creates a resource policy directly on the channel. This
will automatically create a policy on the first call:

```ts
declare const channel: Channel;
channel.addToResourcePolicy(new PolicyStatement({
    sid: 'AllowMediaLiveRoleToAccessEmpChannel',
    principals: [new ArnPrincipal('arn:aws:iam::AccountID:role/MediaLiveAccessRole')],
    effect: Effect.ALLOW,
    actions: ['mediapackagev2:PutObject'],
    resources: [channel.channelArn],
}));
```

## Origin Endpoint

```ts
declare const stack: Stack;
declare const channel: Channel;
new OriginEndpoint(stack, 'myendpoint', {
    channel,
    originEndpointName: 'my-test-endpoint',
    segment: Segment.cmaf(),
    manifests: [
      Manifest.hls({
        manifestName: 'index',
      }),
    ],
});
```

The following code imports an existing origin endpoint using the name attributes:

```ts
declare const stack: Stack;
const originEndpoint = OriginEndpoint.fromOriginEndpointAttributes(stack, 'ImportedOriginEndpoint', {
    channelGroupName: 'MyChannelGroup',
    channelName: 'MyChannel',
    originEndpointName: 'MyExampleOriginEndpoint',
});
```

You can also import from an ARN:

```ts
declare const stack: Stack;
const originEndpoint = OriginEndpoint.fromOriginEndpointArn(stack, 'ImportedOriginEndpoint',
    'arn:aws:mediapackagev2:us-west-2:123456789012:channelGroup/MyGroup/channel/MyChannel/originEndpoint/MyEndpoint',
);
```

The following code creates a resource policy on the origin endpoint. This
will automatically create a policy on the first call:

```ts
declare const origin: OriginEndpoint;

origin.addToResourcePolicy(new PolicyStatement({
    sid: 'AllowRequestsFromCloudFront',
    principals: [new ServicePrincipal('cloudfront.amazonaws.com')],
    effect: Effect.ALLOW,
    actions: ['mediapackagev2:GetHeadObject', 'mediapackagev2:GetObject'],
    resources: [origin.originEndpointArn],
    conditions: {
      StringEquals: {
        'aws:SourceArn': 'arn:aws:cloudfront::123456789012:distribution/AAAAAAAAA',
      },
    },
}));
```

### CDN Authorization

MediaPackage V2 supports two ways to lock an origin endpoint to your CDN:

- **AWS Signature Version 4 (SigV4)** — the CDN signs requests with an IAM
  role. For Amazon CloudFront, see [CloudFront Integration](#cloudfront-integration).
  See the [SigV4 authentication guide][sigv4-auth].
- **Header-based CDN authorization** — the CDN attaches a shared secret in
  a request header that MediaPackage validates. Use this when your CDN
  doesn't support SigV4. See the [CDN authorization guide][cdn-auth].

[sigv4-auth]: https://docs.aws.amazon.com/mediapackage/latest/userguide/sig-v4-authenticating-requests.html
[cdn-auth]: https://docs.aws.amazon.com/mediapackage/latest/userguide/cdn-auth.html

To configure header-based authorization, set `cdnAuth` on the `OriginEndpoint`
props. The L2 auto-creates the endpoint policy with:

- a `PolicyStatement` requiring the `mediapackagev2:RequestHasMatchingCdnAuthHeader`
  condition on every `GetObject` request
- the `CdnAuthConfiguration` block that references the secrets and the read role

If you don't supply a role, one is created with the needed Secrets Manager
and KMS permissions.

```ts
import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';

declare const channel: Channel;
declare const mySecret: secretsmanager.ISecret;

new OriginEndpoint(this, 'OriginEndpoint', {
  channel,
  segment: Segment.ts(),
  manifests: [Manifest.hls({ manifestName: 'index' })],
  cdnAuth: {
    secrets: [mySecret],
  },
});
```

You can still call `addToResourcePolicy()` to add extra statements (e.g. a
harvester allow); they're appended to the auto-created policy alongside the
gating statement.

## Granting Permissions

### Granting Ingest Access to MediaLive

To allow AWS Elemental MediaLive to ingest content into a MediaPackage channel, use the `grants.ingest()` method:

```ts
declare const channel: Channel;
declare const mediaLiveRole: iam.IRole;

// Grant MediaLive permission to ingest content
channel.grants.ingest(mediaLiveRole);
```

### CloudFront Integration

MediaPackage origin endpoints are designed to be used with Content Delivery Network (CDN) like Amazon CloudFront distributions. CloudFront provides caching, DDoS protection, and global content delivery for your streaming content.

The simplest way to connect CloudFront to a MediaPackage V2 endpoint is with `MediaPackageV2Origin`, which automatically creates an Origin Access Control (OAC) and wires the endpoint policy:

```ts
declare const endpoint: OriginEndpoint;
declare const group: ChannelGroup;

new cloudfront.Distribution(this, 'Distribution', {
  defaultBehavior: {
    origin: new MediaPackageV2Origin(endpoint, {
      channelGroup: group,
    }),
  },
});
```

This handles OAC creation, HTTPS-only origin config, and the IAM policy granting CloudFront access to the endpoint (including `GetHeadObject` for MQAR support).

For more control, you can manually configure the policy and OAC:

```ts
declare const originEndpoint: OriginEndpoint;
declare const distribution: cloudfront.Distribution;

originEndpoint.addToResourcePolicy(new iam.PolicyStatement({
  sid: 'AllowCloudFrontServicePrincipal',
  principals: [new iam.ServicePrincipal('cloudfront.amazonaws.com')],
  effect: iam.Effect.ALLOW,
  actions: ['mediapackagev2:GetObject', 'mediapackagev2:GetHeadObject'],
  resources: [originEndpoint.originEndpointArn],
  conditions: {
    StringEquals: {
      'aws:SourceArn': distribution.distributionArn,
    },
  },
}));
```

> **Graduation plan:** `MediaPackageV2Origin` currently lives in this alpha module. When MediaPackage V2 graduates to stable, it will move to `aws-cloudfront-origins` alongside `S3BucketOrigin` and other origin helpers.

## Manifest Configuration

MediaPackage V2 supports multiple manifest formats: HLS, Low-Latency HLS (LL-HLS), DASH, and Microsoft Smooth Streaming (MSS).

### HLS Manifests

```ts
declare const channel: Channel;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf(),
  manifests: [
    Manifest.hls({
      manifestName: 'index',
      manifestWindow: Duration.seconds(60),
      programDateTimeInterval: Duration.seconds(60),
      scteAdMarkerHls: AdMarkerHls.DATERANGE,
    }),
  ],
});
```

### Low-Latency HLS Manifests

```ts
declare const channel: Channel;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf(),
  manifests: [
    Manifest.lowLatencyHLS({
      manifestName: 'index',
      manifestWindow: Duration.seconds(30),
      programDateTimeInterval: Duration.seconds(5),
      childManifestName: 'child',
    }),
  ],
});
```

### DASH Manifests

```ts
declare const channel: Channel;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf(),
  manifests: [
    Manifest.dash({
      manifestName: 'index',
      manifestWindow: Duration.seconds(60),
      minBufferTime: Duration.seconds(30),
      minUpdatePeriod: Duration.seconds(10),
      segmentTemplateFormat: SegmentTemplateFormat.NUMBER_WITH_TIMELINE,
      periodTriggers: [
        DashPeriodTriggers.AVAILS,
        DashPeriodTriggers.DRM_KEY_ROTATION,
      ],
    }),
  ],
});
```

### MSS Manifests

```ts
declare const channel: Channel;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.ism(),
  manifests: [
    Manifest.mss({
      manifestName: 'index',
      manifestWindow: Duration.seconds(60),
      manifestLayout: MssManifestLayout.COMPACT,
    }),
  ],
});
```

### Multiple Manifests

You can configure multiple manifest formats for a single origin endpoint:

```ts
declare const channel: Channel;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf(),
  manifests: [
    Manifest.hls({ manifestName: 'hls' }),
    Manifest.dash({ manifestName: 'dash' }),
  ],
});
```

| Segment type | Supported manifests |
|--------|--------|
| Segment.cmaf() | HLS, LL-HLS, DASH |
| Segment.ts() | HLS, LL-HLS |
| Segment.ism() | MSS |

Each origin endpoint has a single segment configuration. If you need segments with different configurations, use multiple origin endpoints on the same channel.

@see https://docs.aws.amazon.com/mediapackage/latest/userguide/endpoints-create.html

## Manifest Filtering

Manifest filters control which variants are included in the manifest. Filters are type-safe and validated against the [MediaPackage manifest filtering rules](https://docs.aws.amazon.com/mediapackage/latest/userguide/manifest-filter-query-parameters.html).

| Filter | Method |
|--------|--------|
| Audio / video bitrate | `bitrate()`, `bitrateRange()`, `bitrateCombo()` |
| Audio channels, sample rate, video height, framerate, trickplay height | `numeric()`, `numericList()`, `numericRange()`, `numericCombo()` |
| Audio codec | `audioCodec()`, `audioCodecList()` |
| Video codec | `videoCodec()`, `videoCodecList()` |
| Video dynamic range | `videoDynamicRange()`, `videoDynamicRangeList()` |
| Trickplay type | `trickplayType()`, `trickplayTypeList()` |
| Audio / subtitle language | `text()`, `textList()` |
| Advanced patterns | `custom()` |

The following example creates an HD streaming endpoint that serves only H.264/H.265 content between 1–5 Mbps with stereo audio in English or French:

```ts
declare const channel: Channel;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf(),
  manifests: [
    Manifest.hls({
      manifestName: 'index',
      filterConfiguration: {
        manifestFilter: [
          ManifestFilter.bitrateRange(BitrateFilterKey.VIDEO_BITRATE, Bitrate.mbps(1), Bitrate.mbps(5)),
          ManifestFilter.numericRange(NumericFilterKey.VIDEO_HEIGHT, 720, 1080),
          ManifestFilter.videoCodecList([VideoCodec.H264, VideoCodec.H265]),
          ManifestFilter.numeric(NumericFilterKey.AUDIO_CHANNELS, 2),
          ManifestFilter.textList(TextFilterKey.AUDIO_LANGUAGE, ['en-US', 'fr']),
        ],
        timeDelay: Duration.seconds(30),
      },
    }),
  ],
});
```

For advanced patterns that combine ranges and single values, use `numericCombo()` or `bitrateCombo()`:

```ts
declare const channel: Channel;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf(),
  manifests: [
    Manifest.hls({
      manifestName: 'index',
      filterConfiguration: {
        manifestFilter: [
          // video_height:240-360,720-1080,1440
          ManifestFilter.numericCombo(NumericFilterKey.VIDEO_HEIGHT, [
            NumericExpression.range(240, 360),
            NumericExpression.range(720, 1080),
            NumericExpression.value(1440),
          ]),
        ],
      },
    }),
  ],
});
```

### DRM Settings

You can exclude session keys from HLS and LL-HLS multivariant playlists using the `drmSettings` filter configuration. This improves compatibility with legacy HLS clients and provides more granular access control:

```ts
declare const channel: Channel;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf(),
  manifests: [
    Manifest.hls({
      manifestName: 'index',
      filterConfiguration: {
        drmSettings: [DrmSettingsKey.EXCLUDE_SESSION_KEYS],
      },
    }),
  ],
});
```

## Start Tag Configuration

Configure where playback should start in HLS and LL-HLS manifests using the EXT-X-START tag:

```ts
declare const channel: Channel;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf(),
  manifests: [
    Manifest.hls({
      manifestName: 'index',
      startTag: StartTag.of(10),
    }),
  ],
});
```

## Segment Configuration

Configure segment settings for your origin endpoint.

```ts
declare const channel: Channel;

new OriginEndpoint(this, 'TsEndpoint', {
  channel,
  segment: Segment.ts({
    duration: Duration.seconds(6),
    name: 'segment',
    includeDvbSubtitles: true,
    useAudioRenditionGroup: true,
    includeIframeOnlyStreams: false,
    scteFilter: [
      ScteMessageType.BREAK,
      ScteMessageType.DISTRIBUTOR_ADVERTISEMENT,
    ],
  }),
  manifests: [Manifest.hls({ manifestName: 'index' })],
});

new OriginEndpoint(this, 'CmafEndpoint', {
  channel,
  segment: Segment.cmaf({
    duration: Duration.seconds(6),
    name: 'segment',
    includeIframeOnlyStreams: true,
    scteFilter: [ScteMessageType.DISTRIBUTOR_ADVERTISEMENT],
  }),
  manifests: [Manifest.hls({ manifestName: 'index' })],
});

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf(),
  manifests: [Manifest.hls({ manifestName: 'index' })],
});
```

## Encryption and DRM

Protect your content with encryption using SPEKE (Secure Packager and Encoder Key Exchange). Each container type has its own encryption class with type-safe options:

### CMAF Encryption

```ts
declare const channel: Channel;
declare const spekeRole: iam.IRole;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf({
    encryption: CmafEncryption.speke({
      method: CmafEncryptionMethod.CBCS,
      drmSystems: [CmafDrmSystem.FAIRPLAY, CmafDrmSystem.WIDEVINE],
      resourceId: 'my-content-id',
      url: 'https://example.com/speke',
      role: spekeRole,
      keyRotationInterval: Duration.seconds(300),
      audioPreset: PresetSpeke20Audio.PRESET_AUDIO_2,
      videoPreset: PresetSpeke20Video.PRESET_VIDEO_2,
    }),
  }),
  manifests: [Manifest.hls({ manifestName: 'index' })],
});
```

### TS Encryption

```ts
declare const channel: Channel;
declare const spekeRole: iam.IRole;

new OriginEndpoint(this, 'TsEndpoint', {
  channel,
  segment: Segment.ts({
    encryption: TsEncryption.speke({
      method: TsEncryptionMethod.SAMPLE_AES,
      resourceId: 'my-content-id',
      url: 'https://example.com/speke',
      role: spekeRole,
    }),
  }),
  manifests: [Manifest.hls({ manifestName: 'index' })],
});
```

TS encryption defaults the DRM system based on the method: FairPlay for `SAMPLE_AES`, Clear Key AES 128 for `AES_128`. You can override this with the `drmSystems` property using `TsDrmSystem`.

### Content Key Encryption

You can add content key encryption by providing a certificate imported into AWS Certificate Manager. Your DRM key provider must support content key encryption for this to work:

```ts
declare const channel: Channel;
declare const spekeRole: iam.IRole;
declare const certificate: certificatemanager.ICertificate;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf({
    encryption: CmafEncryption.speke({
      method: CmafEncryptionMethod.CBCS,
      drmSystems: [CmafDrmSystem.FAIRPLAY],
      resourceId: 'my-content-id',
      url: 'https://example.com/speke',
      role: spekeRole,
      certificate,
    }),
  }),
  manifests: [Manifest.hls({ manifestName: 'index' })],
});
```

### Excluding Segment DRM Metadata

For CMAF content, you can exclude DRM metadata from segments:

```ts
declare const channel: Channel;
declare const spekeRole: iam.IRole;

new OriginEndpoint(this, 'Endpoint', {
  channel,
  segment: Segment.cmaf({
    encryption: CmafEncryption.speke({
      method: CmafEncryptionMethod.CBCS,
      drmSystems: [CmafDrmSystem.FAIRPLAY],
      resourceId: 'my-content-id',
      url: 'https://example.com/speke',
      role: spekeRole,
      excludeSegmentDrmMetadata: true,
    }),
  }),
  manifests: [Manifest.hls({ manifestName: 'index' })],
});
```

### ISM (Smooth Streaming) Encryption

ISM endpoints use CENC encryption with PlayReady. Audio and video presets are always `SHARED`, and key rotation is not supported. The DRM system defaults to PlayReady:

```ts
declare const channel: Channel;
declare const spekeRole: iam.IRole;

new OriginEndpoint(this, 'IsmEndpoint', {
  channel,
  segment: Segment.ism({
    encryption: IsmEncryption.speke({
      resourceId: 'my-content-id',
      url: 'https://example.com/speke',
      role: spekeRole,
    }),
  }),
  manifests: [Manifest.mss({ manifestName: 'index' })],
});
```

## CloudWatch Metrics

MediaPackage V2 resources expose CloudWatch metrics for monitoring. You can create alarms and dashboards using these metrics:

```ts
declare const channelGroup: ChannelGroup;
declare const channel: Channel;
declare const endpoint: OriginEndpoint;

// Create a CloudWatch alarm on channel group egress bytes
const alarm = channelGroup.metricEgressBytes().createAlarm(this, 'HighEgress', {
  threshold: 1000,
  evaluationPeriods: 1,
});

// Monitor channel ingress response time
channel.metricIngressResponseTime().createAlarm(this, 'SlowIngress', {
  threshold: 1000,
  evaluationPeriods: 2,
});

// Track origin endpoint request count
const requestMetric = endpoint.metricEgressRequestCount({
  statistic: 'sum',
  period: Duration.minutes(5),
});
```

Available metrics include:

- `metricIngressBytes()` - Bytes ingested
- `metricEgressBytes()` - Bytes delivered
- `metricIngressResponseTime()` - Ingress response time (average)
- `metricEgressResponseTime()` - Egress response time (average)
- `metricIngressRequestCount()` - Number of ingress requests
- `metricEgressRequestCount()` - Number of egress requests

All metrics support standard CloudWatch metric options for customizing period, statistic, and dimensions.

## Types

| Name | Kind | Summary |
| --- | --- | --- |
| [`Channel`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.Channel) | Construct (L2) | Defines an AWS Elemental MediaPackage V2 Channel. |
| [`ChannelGroup`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ChannelGroup) | Construct (L2) | Defines an AWS Elemental MediaPackage V2 Channel Group. |
| [`ChannelPolicy`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ChannelPolicy) | Construct (L2) | The channel policy for an AWS Elemental MediaPackage V2 channel. |
| [`OriginEndpoint`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.OriginEndpoint) | Construct (L2) | Defines an AWS Elemental MediaPackage V2 Origin Endpoint. |
| [`OriginEndpointPolicy`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.OriginEndpointPolicy) | Construct (L2) | The origin endpoint policy for an AWS Elemental MediaPackage V2 Origin Endpoint. |
| [`AdMarkerDash`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.AdMarkerDash) | Enum | Choose how ad markers are included in the packaged content. |
| [`AdMarkerHls`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.AdMarkerHls) | Enum | Choose how SCTE-35 ad markers are included in HLS and LL-HLS manifests. |
| [`AudioCodec`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.AudioCodec) | Enum | Accepted audio codec values for manifest filtering. |
| [`BitrateExpression`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.BitrateExpression) | Class | Represents a bitrate filter expression segment — either a single value or a range. |
| [`BitrateFilterKey`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.BitrateFilterKey) | Enum | Bitrate manifest filter keys. |
| [`CdnAuthConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.CdnAuthConfiguration) | Struct | Options for configuring CDN Authorization Configuration. |
| [`ChannelAttributes`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ChannelAttributes) | Struct | Represents a Channel defined outside of this stack. |
| [`ChannelGrants`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ChannelGrants) | Facade | Collection of grant methods for a IChannelRef. |
| [`ChannelGroupAttributes`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ChannelGroupAttributes) | Struct | Attributes to enable import of a Channel Group, which in turn can be used to create a Channel and OriginEndpoint). |
| [`ChannelGroupProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ChannelGroupProps) | Struct | Properties for the Channel Group. |
| [`ChannelOptions`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ChannelOptions) | Struct | Configuration options for an AWS Elemental MediaPackage V2 Channel. |
| [`ChannelPolicyProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ChannelPolicyProps) | Struct | Properties for the Channel Policy. |
| [`ChannelProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ChannelProps) | Struct | Properties to set on a Channel. |
| [`CmafDrmSystem`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.CmafDrmSystem) | Enum | DRM systems available for CMAF encryption. |
| [`CmafEncryption`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.CmafEncryption) | Class | Encryption configuration for CMAF segments. |
| [`CmafEncryptionMethod`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.CmafEncryptionMethod) | Enum | Encryption methods for CMAF container type. |
| [`CmafInputProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.CmafInputProps) | Struct | Properties for CMAF input configuration. |
| [`CmafSegmentProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.CmafSegmentProps) | Struct | Properties for CMAF segment configuration. |
| [`CmafSpekeEncryptionProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.CmafSpekeEncryptionProps) | Struct | Properties for CMAF SPEKE encryption configuration. |
| [`ContainerType`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ContainerType) | Enum | The type of container to attach to this origin endpoint. |
| [`DashBaseUrlProperty`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DashBaseUrlProperty) | Struct | The base URLs to use for retrieving segments. |
| [`DashDvbFontDownload`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DashDvbFontDownload) | Struct | For use with DVB-DASH profiles only. |
| [`DashDvbMetricsReporting`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DashDvbMetricsReporting) | Struct | For use with DVB-DASH profiles only. |
| [`DashDvbSettings`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DashDvbSettings) | Struct | The font download and error reporting information that you want MediaPackage to pass through to the manifest. |
| [`DashManifestCompactness`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DashManifestCompactness) | Enum | STANDARD indicates a default manifest, which is compacted. |
| [`DashManifestConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DashManifestConfiguration) | Struct | The DASH manifest configuration associated with the origin endpoint. |
| [`DashPeriodTriggers`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DashPeriodTriggers) | Enum | Options for triggers which cause AWS Elemental MediaPackage to create media presentation description (MPD) periods in the output manifest. |
| [`DashProgramInformation`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DashProgramInformation) | Struct | Details about the content that you want MediaPackage to pass through in the manifest to the playback device. |
| [`DashSubtitleConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DashSubtitleConfiguration) | Struct | Configuration for subtitles in DASH manifests. |
| [`DashTtmlConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DashTtmlConfiguration) | Struct | Configuration for TTML subtitles in DASH manifests. |
| [`DashUtcTimingMode`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DashUtcTimingMode) | Enum | The UTC timing mode for DASH. |
| [`DrmSettingsKey`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DrmSettingsKey) | Enum | DRM settings keys for manifest filter configuration. |
| [`DrmSignalling`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.DrmSignalling) | Enum | DRM signaling determines the way DASH manifest signals the DRM content. |
| [`EncryptionConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.EncryptionConfiguration) | Class | Base class for encryption configurations. |
| [`EndpointErrorConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.EndpointErrorConfiguration) | Enum | Endpoint error configuration options. |
| [`FilterConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.FilterConfiguration) | Struct | 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. |
| [`HeadersCMSD`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.HeadersCMSD) | Class | The settings for what common media server data (CMSD) headers AWS Elemental MediaPackage includes in responses to the CDN. |
| [`HlsManifestConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.HlsManifestConfiguration) | Struct | The HLS manifest configuration associated with the origin endpoint. |
| [`IChannel`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.IChannel) | Interface | Represents a MediaPackage V2 Channel. |
| [`IChannelGroup`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.IChannelGroup) | Interface | Interface for AWS Elemental MediaPackage V2 Channel Group. |
| [`IngestEndpoint`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.IngestEndpoint) | Enum | Ingest Endpoint options. |
| [`InputConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.InputConfiguration) | Class | Input configuration for a MediaPackage V2 Channel. |
| [`InputSwitchConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.InputSwitchConfiguration) | Struct | Input Switch Configuration. |
| [`InputType`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.InputType) | Enum | The input type will be an immutable field which will be used to define whether the channel will allow CMAF ingest or HLS ingest. |
| [`IOriginEndpoint`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.IOriginEndpoint) | Interface | Origin Endpoint interface. |
| [`IsmDrmSystem`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.IsmDrmSystem) | Enum | DRM systems available for ISM encryption. |
| [`IsmEncryption`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.IsmEncryption) | Class | Encryption configuration for ISM (Microsoft Smooth Streaming) segments. |
| [`IsmSegmentProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.IsmSegmentProps) | Struct | Properties for ISM (Microsoft Smooth Streaming) segment configuration. |
| [`IsmSpekeEncryptionProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.IsmSpekeEncryptionProps) | Struct | Properties for ISM SPEKE encryption configuration. |
| [`LowLatencyHlsManifestConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.LowLatencyHlsManifestConfiguration) | Struct | Specify a low-latency HTTP live streaming (LL-HLS) manifest configuration. |
| [`Manifest`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.Manifest) | Class | Manifest to add to Origin Endpoint. |
| [`ManifestFilter`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ManifestFilter) | Class | Enables you to create filters for your Origin Endpoint. |
| [`MediaPackageV2Origin`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.MediaPackageV2Origin) | Class | A CloudFront Origin for AWS Elemental MediaPackage V2 endpoints. |
| [`MediaPackageV2OriginProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.MediaPackageV2OriginProps) | Struct | Properties for a MediaPackage V2 Origin with OAC. |
| [`MssManifestConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.MssManifestConfiguration) | Struct | The MSS manifest configuration associated with the origin endpoint. |
| [`MssManifestLayout`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.MssManifestLayout) | Enum | The layout of the MSS manifest. |
| [`NumericExpression`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.NumericExpression) | Class | Represents a numeric filter expression segment — either a single value or a range. |
| [`NumericFilterKey`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.NumericFilterKey) | Enum | Numeric manifest filter keys. |
| [`OriginEndpointAttributes`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.OriginEndpointAttributes) | Struct | Represents an Origin Endpoint defined outside of this stack. |
| [`OriginEndpointOptions`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.OriginEndpointOptions) | Struct | Configuration parameters for an AWS Elemental MediaPackage V2 Origin Endpoint. |
| [`OriginEndpointPolicyProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.OriginEndpointPolicyProps) | Struct | Properties for Origin Endpoint policy. |
| [`OriginEndpointProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.OriginEndpointProps) | Struct | Properties to set on an Origin Endpoint. |
| [`PresetSpeke20Audio`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.PresetSpeke20Audio) | Enum | A collection of audio encryption presets. |
| [`PresetSpeke20Video`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.PresetSpeke20Video) | Enum | The SPEKE Version 2.0 preset video associated with the encryption contract configuration of the origin endpoint. |
| [`ScteInSegments`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ScteInSegments) | Enum | Controls whether SCTE-35 messages are included in segment files. |
| [`ScteMessageType`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.ScteMessageType) | Enum | SCTE-35 message type options available. |
| [`Segment`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.Segment) | Class | Helper class for creating segment configurations. |
| [`SegmentConfiguration`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.SegmentConfiguration) | Struct | The segment configuration, including the segment name, duration, and other configuration values. |
| [`SegmentPropsBase`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.SegmentPropsBase) | Struct | Base properties common to all segment configurations. |
| [`SegmentTemplateFormat`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.SegmentTemplateFormat) | Enum | The type of variable that MediaPackage uses in the media attribute of the SegmentTemplate tag. |
| [`StartTag`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.StartTag) | Class | Helper class for creating EXT-X-START tags in HLS playlists. |
| [`StartTagOptions`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.StartTagOptions) | Struct | Options for configuring a StartTag. |
| [`TextFilterKey`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.TextFilterKey) | Enum | Text manifest filter keys for free-form string values. |
| [`TrickplayType`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.TrickplayType) | Enum | Accepted trickplay type values for manifest filtering. |
| [`TsDrmSystem`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.TsDrmSystem) | Enum | DRM systems available for TS encryption. |
| [`TsEncryption`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.TsEncryption) | Class | Encryption configuration for TS segments. |
| [`TsEncryptionMethod`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.TsEncryptionMethod) | Enum | Encryption methods for TS container type. |
| [`TsSegmentProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.TsSegmentProps) | Struct | Properties for TS (Transport Stream) segment configuration. |
| [`TsSpekeEncryptionProps`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.TsSpekeEncryptionProps) | Struct | Properties for TS SPEKE encryption configuration. |
| [`TtmlProfile`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.TtmlProfile) | Enum | Options for TTML Profile. |
| [`VideoCodec`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.VideoCodec) | Enum | Accepted video codec values for manifest filtering. |
| [`VideoDynamicRange`](/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.VideoDynamicRange) | Enum | Accepted video dynamic range values for manifest filtering. |