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

package/lib/sdi-source.d.ts

@@ -0,0 +1,124 @@
+import type { IResource } from 'aws-cdk-lib';
+import { Resource } from 'aws-cdk-lib';
+import type { ISdiSourceRef, SdiSourceReference } from 'aws-cdk-lib/aws-medialive';
+import type { Construct } from 'constructs';
+/**
+ * Represents a MediaLive SDI Source.
+ */
+export interface ISdiSource extends IResource, ISdiSourceRef {
+    /**
+     * The SDI Source ARN.
+     * @attribute
+     */
+    readonly sdiSourceArn: string;
+    /**
+     * The SDI Source ID.
+     * @attribute
+     */
+    readonly sdiSourceId: string;
+    /**
+     * The list of inputs currently using this SDI source.
+     * @attribute
+     */
+    readonly sdiSourceInputs?: string[];
+    /**
+     * The current state of the SDI source.
+     * @attribute
+     */
+    readonly sdiSourceState?: string;
+}
+/**
+ * Properties for creating an SDI Source.
+ */
+export interface SdiSourceProps {
+    /**
+     * The name of the SDI source.
+     * @default - auto-generated name
+     */
+    readonly sdiSourceName?: string;
+    /**
+     * Type of SDI input.
+     */
+    readonly type: SdiType;
+    /**
+     * SDI Mode, only applicable for QUAD type.
+     * @default - no mode
+     */
+    readonly mode?: SdiMode;
+    /**
+     * Tags to add to the SDI source.
+     * @default - no tagging
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
+}
+/**
+ * The type of SDI input.
+ */
+export declare class SdiType {
+    /** Single SDI input */
+    static readonly SINGLE: SdiType;
+    /** Quad SDI input */
+    static readonly QUAD: SdiType;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): SdiType;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/**
+ * Mode when quad SDI input is selected.
+ */
+export declare class SdiMode {
+    /** Interleave mode */
+    static readonly INTERLEAVE: SdiMode;
+    /** Quadrant mode */
+    static readonly QUADRANT: SdiMode;
+    /** A value not yet modelled by AWS CDK. */
+    static of(value: string): SdiMode;
+    /** The underlying string value passed to CloudFormation. */
+    readonly value: string;
+    private constructor();
+}
+/**
+ * Attributes for importing an existing SDI Source.
+ */
+export interface SdiSourceAttributes {
+    /**
+     * The SDI Source ARN.
+     * @attribute
+     */
+    readonly sdiSourceArn: string;
+    /**
+     * The SDI Source ID.
+     * @attribute
+     */
+    readonly sdiSourceId: string;
+}
+/**
+ * Defines an AWS Elemental MediaLive SDI Source.
+ */
+export declare class SdiSource extends Resource implements ISdiSource {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /** Import an existing SDI source by its attributes. */
+    static fromSdiSourceAttributes(scope: Construct, id: string, attrs: SdiSourceAttributes): ISdiSource;
+    readonly sdiSourceArn: string;
+    /**
+     * The SDI Source ID.
+     * @attribute
+     */
+    readonly sdiSourceId: string;
+    /**
+     * The list of inputs currently using this SDI source.
+     */
+    readonly sdiSourceInputs?: string[];
+    /**
+     * The current state of the SDI source.
+     */
+    readonly sdiSourceState?: string;
+    /** A reference to this SDI Source resource. */
+    get sdiSourceRef(): SdiSourceReference;
+    constructor(scope: Construct, id: string, props: SdiSourceProps);
+}

package/lib/sdi-source.js

@@ -0,0 +1,180 @@
+"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.SdiSource = exports.SdiMode = exports.SdiType = 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_medialive_1 = require("aws-cdk-lib/aws-medialive");
+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");
+/**
+ * The type of SDI input.
+ */
+class SdiType {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.SdiType", version: "2.268.0-alpha.0" };
+    /** Single SDI input */
+    static SINGLE = new SdiType('SINGLE');
+    /** Quad SDI input */
+    static QUAD = new SdiType('QUAD');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new SdiType(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.SdiType = SdiType;
+/**
+ * Mode when quad SDI input is selected.
+ */
+class SdiMode {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.SdiMode", version: "2.268.0-alpha.0" };
+    /** Interleave mode */
+    static INTERLEAVE = new SdiMode('INTERLEAVE');
+    /** Quadrant mode */
+    static QUADRANT = new SdiMode('QUADRANT');
+    /** A value not yet modelled by AWS CDK. */
+    static of(value) {
+        return new SdiMode(value);
+    }
+    /** The underlying string value passed to CloudFormation. */
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.SdiMode = SdiMode;
+/**
+ * Defines an AWS Elemental MediaLive SDI Source.
+ */
+let SdiSource = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = aws_cdk_lib_1.Resource;
+    var SdiSource = 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);
+            SdiSource = _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-medialive-alpha.SdiSource", version: "2.268.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-medialive-alpha.SdiSource';
+        /** Import an existing SDI source by its attributes. */
+        static fromSdiSourceAttributes(scope, id, attrs) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_SdiSourceAttributes(attrs);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.fromSdiSourceAttributes);
+                }
+                throw error;
+            }
+            class Import extends aws_cdk_lib_1.Resource {
+                sdiSourceArn = attrs.sdiSourceArn;
+                sdiSourceId = attrs.sdiSourceId;
+                sdiSourceInputs = undefined;
+                sdiSourceState = undefined;
+                get sdiSourceRef() {
+                    return { sdiSourceId: this.sdiSourceId, sdiSourceArn: this.sdiSourceArn };
+                }
+            }
+            return new Import(scope, id);
+        }
+        sdiSourceArn;
+        /**
+         * The SDI Source ID.
+         * @attribute
+         */
+        sdiSourceId;
+        /**
+         * The list of inputs currently using this SDI source.
+         */
+        sdiSourceInputs;
+        /**
+         * The current state of the SDI source.
+         */
+        sdiSourceState;
+        /** A reference to this SDI Source resource. */
+        get sdiSourceRef() {
+            return { sdiSourceId: this.sdiSourceId, sdiSourceArn: this.sdiSourceArn };
+        }
+        constructor(scope, id, props) {
+            super(scope, id, {
+                physicalName: props.sdiSourceName ?? aws_cdk_lib_1.Lazy.string({ produce: () => aws_cdk_lib_1.Names.uniqueResourceName(this, { maxLength: 256 }) }),
+            });
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_medialive_alpha_SdiSourceProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, SdiSource);
+                }
+                throw error;
+            }
+            if (props.mode && props.type.value !== SdiType.QUAD.value) {
+                throw new aws_cdk_lib_1.ValidationError((0, helpers_internal_1.lit) `SdiModeOnlyForQuad`, 'mode is only valid when type is QUAD', this);
+            }
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            const resource = new aws_medialive_1.CfnSdiSource(this, 'Resource', {
+                name: this.physicalName,
+                type: props.type?.value,
+                mode: props.mode?.value,
+                tags: props.tags ? Object.entries(props.tags).map(([key, value]) => ({ key, value })) : undefined,
+            });
+            this.sdiSourceArn = resource.attrArn;
+            this.sdiSourceId = resource.ref;
+            this.sdiSourceInputs = resource.attrInputs;
+            this.sdiSourceState = resource.attrState;
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return SdiSource = _classThis;
+})();
+exports.SdiSource = SdiSource;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdi-source.js","sourceRoot":"","sources":["sdi-source.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IResource } from 'aws-cdk-lib';\nimport { Resource, Lazy, Names, ValidationError } from 'aws-cdk-lib';\nimport type { ISdiSourceRef, SdiSourceReference } from 'aws-cdk-lib/aws-medialive';\nimport { CfnSdiSource } from 'aws-cdk-lib/aws-medialive';\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';\n\n/**\n * Represents a MediaLive SDI Source.\n */\nexport interface ISdiSource extends IResource, ISdiSourceRef {\n  /**\n   * The SDI Source ARN.\n   * @attribute\n   */\n  readonly sdiSourceArn: string;\n\n  /**\n   * The SDI Source ID.\n   * @attribute\n   */\n  readonly sdiSourceId: string;\n\n  /**\n   * The list of inputs currently using this SDI source.\n   * @attribute\n   */\n  readonly sdiSourceInputs?: string[];\n\n  /**\n   * The current state of the SDI source.\n   * @attribute\n   */\n  readonly sdiSourceState?: string;\n}\n\n/**\n * Properties for creating an SDI Source.\n */\nexport interface SdiSourceProps {\n  /**\n   * The name of the SDI source.\n   * @default - auto-generated name\n   */\n  readonly sdiSourceName?: string;\n\n  /**\n   * Type of SDI input.\n   */\n  readonly type: SdiType;\n\n  /**\n   * SDI Mode, only applicable for QUAD type.\n   * @default - no mode\n   */\n  readonly mode?: SdiMode;\n\n  /**\n   * Tags to add to the SDI source.\n   * @default - no tagging\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * The type of SDI input.\n */\nexport class SdiType {\n  /** Single SDI input */\n  public static readonly SINGLE = new SdiType('SINGLE');\n  /** Quad SDI input */\n  public static readonly QUAD = new SdiType('QUAD');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): SdiType {\n    return new SdiType(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 * Mode when quad SDI input is selected.\n */\nexport class SdiMode {\n  /** Interleave mode */\n  public static readonly INTERLEAVE = new SdiMode('INTERLEAVE');\n  /** Quadrant mode */\n  public static readonly QUADRANT = new SdiMode('QUADRANT');\n\n  /** A value not yet modelled by AWS CDK. */\n  public static of(value: string): SdiMode {\n    return new SdiMode(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 * Attributes for importing an existing SDI Source.\n */\nexport interface SdiSourceAttributes {\n  /**\n   * The SDI Source ARN.\n   * @attribute\n   */\n  readonly sdiSourceArn: string;\n\n  /**\n   * The SDI Source ID.\n   * @attribute\n   */\n  readonly sdiSourceId: string;\n}\n\n/**\n * Defines an AWS Elemental MediaLive SDI Source.\n */\n@propertyInjectable\nexport class SdiSource extends Resource implements ISdiSource {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-medialive-alpha.SdiSource';\n\n  /** Import an existing SDI source by its attributes. */\n  public static fromSdiSourceAttributes(scope: Construct, id: string, attrs: SdiSourceAttributes): ISdiSource {\n    class Import extends Resource implements ISdiSource {\n      public readonly sdiSourceArn = attrs.sdiSourceArn;\n      public readonly sdiSourceId = attrs.sdiSourceId;\n      public readonly sdiSourceInputs = undefined;\n      public readonly sdiSourceState = undefined;\n      public get sdiSourceRef(): SdiSourceReference {\n        return { sdiSourceId: this.sdiSourceId, sdiSourceArn: this.sdiSourceArn };\n      }\n    }\n    return new Import(scope, id);\n  }\n\n  public readonly sdiSourceArn: string;\n\n  /**\n   * The SDI Source ID.\n   * @attribute\n   */\n  public readonly sdiSourceId: string;\n\n  /**\n   * The list of inputs currently using this SDI source.\n   */\n  public readonly sdiSourceInputs?: string[];\n\n  /**\n   * The current state of the SDI source.\n   */\n  public readonly sdiSourceState?: string;\n\n  /** A reference to this SDI Source resource. */\n  public get sdiSourceRef(): SdiSourceReference {\n    return { sdiSourceId: this.sdiSourceId, sdiSourceArn: this.sdiSourceArn };\n  }\n\n  constructor(scope: Construct, id: string, props: SdiSourceProps) {\n    super(scope, id, {\n      physicalName: props.sdiSourceName ?? Lazy.string({ produce: () => Names.uniqueResourceName(this, { maxLength: 256 }) }),\n    });\n\n    if (props.mode && props.type.value !== SdiType.QUAD.value) {\n      throw new ValidationError(lit`SdiModeOnlyForQuad`, 'mode is only valid when type is QUAD', this);\n    }\n\n    addConstructMetadata(this, props);\n\n    const resource = new CfnSdiSource(this, 'Resource', {\n      name: this.physicalName,\n      type: props.type?.value,\n      mode: props.mode?.value,\n      tags: props.tags ? Object.entries(props.tags).map(([key, value]) => ({ key, value })) : undefined,\n    });\n\n    this.sdiSourceArn = resource.attrArn;\n    this.sdiSourceId = resource.ref;\n    this.sdiSourceInputs = resource.attrInputs;\n    this.sdiSourceState = resource.attrState;\n  }\n}\n"]}

package/lib/shared.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The length of a media segment for an output group.
+ *
+ * Express the length in whole seconds with {@link Segment.seconds} or in milliseconds
+ * with {@link Segment.milliseconds}. Some output groups (e.g. HLS) only support
+ * whole-second segments and will reject sub-second millisecond values.
+ */
+export declare class Segment {
+    /**
+     * A segment length in whole seconds.
+     * @param value Number of seconds (non-negative integer).
+     */
+    static seconds(value: number): Segment;
+    /**
+     * A segment length in milliseconds.
+     * @param value Number of milliseconds (non-negative integer).
+     */
+    static milliseconds(value: number): Segment;
+    private constructor();
+}
+/**
+ * The pixel aspect ratio (PAR) of the video.
+ *
+ * Use the predefined constants for standard ratios, or {@link PixelAspectRatio.of} for
+ * a custom ratio.
+ */
+export declare class PixelAspectRatio {
+    /** Square pixels (`1:1`). */
+    static readonly SQUARE: PixelAspectRatio;
+    /**
+     * Define a pixel aspect ratio.
+     *
+     * @param numerator Numerator of the ratio.
+     * @param denominator Denominator of the ratio.
+     */
+    static of(numerator: number, denominator: number): PixelAspectRatio;
+    /**
+     * @param numerator Numerator of the ratio.
+     * @param denominator Denominator of the ratio.
+     */
+    private constructor();
+    /** Returns the string value in `numerator:denominator` form. */
+    toString(): string;
+}

package/lib/shared.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelAspectRatio = exports.Segment = void 0;
+exports.extractResourceId = extractResourceId;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+const enums_1 = require("./enums");
+/**
+ * Parse the trailing `:<id>` resource name out of a MediaLive ARN
+ * (`arn:<partition>:medialive:<region>:<account>:<resourceType>:<id>`).
+ *
+ * @param arn The full resource ARN.
+ * @param resourceType The MediaLive resource type, used only in the error message
+ * (e.g. `'Channel'`, `'Input'`).
+ * @internal
+ */
+function extractResourceId(arn, resourceType) {
+    const parsed = aws_cdk_lib_1.Arn.split(arn, aws_cdk_lib_1.ArnFormat.COLON_RESOURCE_NAME).resourceName;
+    if (parsed === undefined) {
+        throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `InvalidMediaLiveArn`, `Could not parse MediaLive ${resourceType} ARN: ${arn}. Expected format: arn:<partition>:medialive:<region>:<account>:<resourceType>:<id>`);
+    }
+    return parsed;
+}
+/**
+ * The length of a media segment for an output group.
+ *
+ * Express the length in whole seconds with {@link Segment.seconds} or in milliseconds
+ * with {@link Segment.milliseconds}. Some output groups (e.g. HLS) only support
+ * whole-second segments and will reject sub-second millisecond values.
+ */
+class Segment {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.Segment", version: "2.268.0-alpha.0" };
+    /**
+     * A segment length in whole seconds.
+     * @param value Number of seconds (non-negative integer).
+     */
+    static seconds(value) {
+        return new Segment(value, enums_1.SegmentLengthUnits.SECONDS);
+    }
+    /**
+     * A segment length in milliseconds.
+     * @param value Number of milliseconds (non-negative integer).
+     */
+    static milliseconds(value) {
+        return new Segment(value, enums_1.SegmentLengthUnits.MILLISECONDS);
+    }
+    /** @internal */
+    _value;
+    /** @internal */
+    _unitsValue;
+    constructor(value, units) {
+        if (!aws_cdk_lib_1.Token.isUnresolved(value) && (!Number.isInteger(value) || value < 0)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `SegmentLength`, `Segment length must be a non-negative integer, got ${value}`);
+        }
+        this._value = value;
+        this._unitsValue = units;
+    }
+    /**
+     * The raw length value, in the configured units.
+     * @internal
+     */
+    _length() {
+        return this._value;
+    }
+    /**
+     * The length units.
+     * @internal
+     */
+    _units() {
+        return this._unitsValue;
+    }
+    /**
+     * The length in whole seconds, for output groups whose segment length is seconds-only.
+     * Throws when the segment is expressed in sub-second milliseconds.
+     * @internal
+     */
+    _toSeconds() {
+        if (this._unitsValue === enums_1.SegmentLengthUnits.SECONDS) {
+            return this._value;
+        }
+        if (this._value % 1000 !== 0) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `SegmentLengthNotWholeSeconds`, `Segment length for this output group must be a whole number of seconds, got ${this._value} milliseconds`);
+        }
+        return this._value / 1000;
+    }
+}
+exports.Segment = Segment;
+/**
+ * The pixel aspect ratio (PAR) of the video.
+ *
+ * Use the predefined constants for standard ratios, or {@link PixelAspectRatio.of} for
+ * a custom ratio.
+ */
+class PixelAspectRatio {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-medialive-alpha.PixelAspectRatio", version: "2.268.0-alpha.0" };
+    /** Square pixels (`1:1`). */
+    static SQUARE = new PixelAspectRatio(1, 1);
+    /**
+     * Define a pixel aspect ratio.
+     *
+     * @param numerator Numerator of the ratio.
+     * @param denominator Denominator of the ratio.
+     */
+    static of(numerator, denominator) {
+        if (!aws_cdk_lib_1.Token.isUnresolved(numerator) && (!Number.isInteger(numerator) || numerator <= 0)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `PixelAspectRatioNumerator`, `Pixel aspect ratio numerator must be a positive integer, got ${numerator}`);
+        }
+        if (!aws_cdk_lib_1.Token.isUnresolved(denominator) && (!Number.isInteger(denominator) || denominator <= 0)) {
+            throw new aws_cdk_lib_1.UnscopedValidationError((0, helpers_internal_1.lit) `PixelAspectRatioDenominator`, `Pixel aspect ratio denominator must be a positive integer, got ${denominator}`);
+        }
+        return new PixelAspectRatio(numerator, denominator);
+    }
+    /** @internal */
+    _numeratorValue;
+    /** @internal */
+    _denominatorValue;
+    /**
+     * @param numerator Numerator of the ratio.
+     * @param denominator Denominator of the ratio.
+     */
+    constructor(numerator, denominator) {
+        this._numeratorValue = numerator;
+        this._denominatorValue = denominator;
+    }
+    /** Returns the string value in `numerator:denominator` form. */
+    toString() {
+        return `${this._numeratorValue}:${this._denominatorValue}`;
+    }
+    /**
+     * The numerator of the ratio.
+     * @internal
+     */
+    _numerator() {
+        return this._numeratorValue;
+    }
+    /**
+     * The denominator of the ratio.
+     * @internal
+     */
+    _denominator() {
+        return this._denominatorValue;
+    }
+}
+exports.PixelAspectRatio = PixelAspectRatio;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared.js","sourceRoot":"","sources":["shared.ts"],"names":[],"mappings":"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","sourcesContent":["import { Arn, ArnFormat, UnscopedValidationError, Token } from 'aws-cdk-lib';\nimport { lit } from 'aws-cdk-lib/core/lib/helpers-internal';\nimport { SegmentLengthUnits } from './enums';\n\n/**\n * Parse the trailing `:<id>` resource name out of a MediaLive ARN\n * (`arn:<partition>:medialive:<region>:<account>:<resourceType>:<id>`).\n *\n * @param arn The full resource ARN.\n * @param resourceType The MediaLive resource type, used only in the error message\n * (e.g. `'Channel'`, `'Input'`).\n * @internal\n */\nexport function extractResourceId(arn: string, resourceType: string): string {\n  const parsed = Arn.split(arn, ArnFormat.COLON_RESOURCE_NAME).resourceName;\n  if (parsed === undefined) {\n    throw new UnscopedValidationError(\n      lit`InvalidMediaLiveArn`,\n      `Could not parse MediaLive ${resourceType} ARN: ${arn}. Expected format: arn:<partition>:medialive:<region>:<account>:<resourceType>:<id>`,\n    );\n  }\n  return parsed;\n}\n\n/**\n * The length of a media segment for an output group.\n *\n * Express the length in whole seconds with {@link Segment.seconds} or in milliseconds\n * with {@link Segment.milliseconds}. Some output groups (e.g. HLS) only support\n * whole-second segments and will reject sub-second millisecond values.\n */\nexport class Segment {\n  /**\n   * A segment length in whole seconds.\n   * @param value Number of seconds (non-negative integer).\n   */\n  public static seconds(value: number): Segment {\n    return new Segment(value, SegmentLengthUnits.SECONDS);\n  }\n\n  /**\n   * A segment length in milliseconds.\n   * @param value Number of milliseconds (non-negative integer).\n   */\n  public static milliseconds(value: number): Segment {\n    return new Segment(value, SegmentLengthUnits.MILLISECONDS);\n  }\n\n  /** @internal */\n  private readonly _value: number;\n  /** @internal */\n  private readonly _unitsValue: SegmentLengthUnits;\n\n  private constructor(value: number, units: SegmentLengthUnits) {\n    if (!Token.isUnresolved(value) && (!Number.isInteger(value) || value < 0)) {\n      throw new UnscopedValidationError(lit`SegmentLength`, `Segment length must be a non-negative integer, got ${value}`);\n    }\n    this._value = value;\n    this._unitsValue = units;\n  }\n\n  /**\n   * The raw length value, in the configured units.\n   * @internal\n   */\n  public _length(): number {\n    return this._value;\n  }\n\n  /**\n   * The length units.\n   * @internal\n   */\n  public _units(): SegmentLengthUnits {\n    return this._unitsValue;\n  }\n\n  /**\n   * The length in whole seconds, for output groups whose segment length is seconds-only.\n   * Throws when the segment is expressed in sub-second milliseconds.\n   * @internal\n   */\n  public _toSeconds(): number {\n    if (this._unitsValue === SegmentLengthUnits.SECONDS) {\n      return this._value;\n    }\n    if (this._value % 1000 !== 0) {\n      throw new UnscopedValidationError(lit`SegmentLengthNotWholeSeconds`, `Segment length for this output group must be a whole number of seconds, got ${this._value} milliseconds`);\n    }\n    return this._value / 1000;\n  }\n}\n\n/**\n * The pixel aspect ratio (PAR) of the video.\n *\n * Use the predefined constants for standard ratios, or {@link PixelAspectRatio.of} for\n * a custom ratio.\n */\nexport class PixelAspectRatio {\n  /** Square pixels (`1:1`). */\n  public static readonly SQUARE = new PixelAspectRatio(1, 1);\n\n  /**\n   * Define a pixel aspect ratio.\n   *\n   * @param numerator Numerator of the ratio.\n   * @param denominator Denominator of the ratio.\n   */\n  public static of(numerator: number, denominator: number): PixelAspectRatio {\n    if (!Token.isUnresolved(numerator) && (!Number.isInteger(numerator) || numerator <= 0)) {\n      throw new UnscopedValidationError(lit`PixelAspectRatioNumerator`, `Pixel aspect ratio numerator must be a positive integer, got ${numerator}`);\n    }\n    if (!Token.isUnresolved(denominator) && (!Number.isInteger(denominator) || denominator <= 0)) {\n      throw new UnscopedValidationError(lit`PixelAspectRatioDenominator`, `Pixel aspect ratio denominator must be a positive integer, got ${denominator}`);\n    }\n    return new PixelAspectRatio(numerator, denominator);\n  }\n\n  /** @internal */\n  private readonly _numeratorValue: number;\n  /** @internal */\n  private readonly _denominatorValue: number;\n\n  /**\n   * @param numerator Numerator of the ratio.\n   * @param denominator Denominator of the ratio.\n   */\n  private constructor(numerator: number, denominator: number) {\n    this._numeratorValue = numerator;\n    this._denominatorValue = denominator;\n  }\n\n  /** Returns the string value in `numerator:denominator` form. */\n  public toString(): string {\n    return `${this._numeratorValue}:${this._denominatorValue}`;\n  }\n\n  /**\n   * The numerator of the ratio.\n   * @internal\n   */\n  public _numerator(): number {\n    return this._numeratorValue;\n  }\n\n  /**\n   * The denominator of the ratio.\n   * @internal\n   */\n  public _denominator(): number {\n    return this._denominatorValue;\n  }\n}\n"]}