@hypit/hypit 0.0.1 → 0.1.0

package/dist/public/media.d.ts

@@ -0,0 +1,708 @@
+/** Opaque identity for one admitted byte resource. Equal bytes may have different identities. */
+type ResourceId = `res_${string}`;
+type RecordId = string;
+type ModuleRef = {
+    readonly name: string;
+    readonly version: string;
+};
+/**
+ * A Type is its owning Module and its name, and nothing else is compared. Two Types whose values
+ * carry identical shapes are distinct, so one is refused where the other is declared — there is no
+ * structural fallback to fall back to.
+ */
+type TypeRef = {
+    readonly module: ModuleRef;
+    readonly name: string;
+};
+type ProducerRef = {
+    readonly module: ModuleRef;
+    readonly name: string;
+};
+type CapabilityRef = {
+    readonly module: ModuleRef;
+    readonly name: string;
+};
+
+type CanonicalValue = null | boolean | number | string | readonly CanonicalValue[] | {
+    readonly [key: string]: CanonicalValue;
+};
+type BlobRef = {
+    readonly kind: "blob";
+    /** One admitted resource instance. Equal bytes admitted twice keep distinct identities. */
+    readonly resource: ResourceId;
+    readonly size: number;
+    readonly mediaType: string;
+};
+type StoredValue = {
+    readonly kind: "inline";
+    readonly value: CanonicalValue;
+} | BlobRef;
+type ValueSchema = {
+    readonly kind: "null";
+} | {
+    readonly kind: "boolean";
+} | {
+    readonly kind: "number";
+    readonly integer?: boolean;
+    readonly minimum?: number;
+    readonly maximum?: number;
+} | {
+    readonly kind: "string";
+    readonly enum?: readonly string[];
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    /** UI-neutral semantic format shared by authoring, validation and tools. */
+    readonly format?: "color";
+} | {
+    readonly kind: "literal";
+    readonly value: CanonicalValue;
+} | {
+    readonly kind: "array";
+    readonly items: ValueSchema;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+} | {
+    readonly kind: "object";
+    readonly fields: Readonly<Record<string, ObjectFieldSchema>>;
+    readonly allowUnknown?: boolean;
+} | {
+    readonly kind: "oneOf";
+    readonly variants: readonly ValueSchema[];
+} | {
+    readonly kind: "blob";
+    readonly mediaTypes?: readonly string[];
+    readonly maxBytes?: number;
+};
+type ObjectFieldSchema = {
+    readonly schema: ValueSchema;
+    readonly optional?: boolean;
+};
+
+type ModuleDependency = {
+    readonly module: ModuleRef;
+};
+type TypeDeclaration = {
+    readonly name: string;
+};
+type PortDeclaration = {
+    readonly name: string;
+    readonly type: TypeRef;
+};
+type NeedPortDeclaration = {
+    readonly name: string;
+    readonly capability: CapabilityRef;
+    readonly returns: TypeRef;
+};
+type CapabilityDeclaration = {
+    readonly name: string;
+    readonly returns: TypeRef;
+};
+type ProducerDeclaration = {
+    readonly name: string;
+    readonly inputs: readonly PortDeclaration[];
+    readonly outputs: readonly PortDeclaration[];
+    readonly needs: readonly NeedPortDeclaration[];
+};
+type ModuleManifest = {
+    readonly format: "hypit.module@1";
+    readonly name: string;
+    readonly version: string;
+    readonly dependencies: readonly ModuleDependency[];
+    readonly types: readonly TypeDeclaration[];
+    readonly capabilities: readonly CapabilityDeclaration[];
+    readonly producers: readonly ProducerDeclaration[];
+};
+
+type SourceRange = {
+    readonly start: number;
+    readonly end: number;
+};
+/** One typed value in the graph; semantic validation happens at the Host admission boundary. */
+type TypedRecord = {
+    readonly id: RecordId;
+    readonly type: TypeRef;
+    readonly value: StoredValue;
+};
+
+type FragmentInputRef = {
+    readonly kind: "fragment-input";
+    readonly name: string;
+};
+type FragmentOperationRef = {
+    readonly kind: "fragment-operation";
+    readonly operation: string;
+};
+type FragmentValueRef = FragmentInputRef | FragmentOperationRef;
+type FragmentOperationResult = {
+    readonly kind: "output";
+    readonly name: string;
+} | {
+    readonly kind: "need";
+    readonly name: string;
+};
+type FragmentOperation = {
+    readonly id: string;
+    readonly producer: ProducerRef;
+    readonly inputs: Readonly<Record<string, FragmentValueRef>>;
+    readonly result: FragmentOperationResult;
+};
+type FragmentExport = {
+    readonly name: string;
+    readonly type: TypeRef;
+    readonly root: FragmentOperationRef;
+};
+type GraphFragment = {
+    readonly format: "hypit.fragment@1";
+    readonly id: string;
+    readonly inputs: readonly {
+        readonly name: string;
+        readonly type: TypeRef;
+    }[];
+    readonly operations: readonly FragmentOperation[];
+    readonly exports: readonly FragmentExport[];
+};
+
+/** A reference to an authored fact that already exists in the Linked Program. */
+type AuthorRecordRef = {
+    readonly kind: "record";
+    readonly id: string;
+};
+/** A symbolic reference to one public export of another component instance. */
+type AuthorComponentOutputRef = {
+    readonly kind: "component-output";
+    readonly component: string;
+    readonly output: string;
+};
+type AuthorValueRef = AuthorRecordRef | AuthorComponentOutputRef;
+/**
+ * One author-visible component call. `outputs` binds every public Fragment export to a Logical Output.
+ */
+type AuthorComponent = {
+    readonly id: string;
+    readonly fragment: string;
+    readonly inputs: Readonly<Record<string, AuthorValueRef>>;
+    readonly outputs: Readonly<Record<string, string>>;
+};
+
+type SourceAssetRequest = {
+    readonly from: string;
+    readonly mediaType: string;
+    /** Package-owned bytes admitted by the compiler before a Workspace is consulted. */
+    readonly bytes?: Uint8Array;
+    readonly range?: SourceRange;
+};
+type ResolvedSourceAsset = {
+    readonly artifact: BlobRef;
+};
+
+/** A semantic source dependency requested by a Frontend or package-owned Surface. */
+type AuthorSourceAssetRequest = SourceAssetRequest;
+type ResolvedAuthorSourceAsset = ResolvedSourceAsset;
+/**
+ * One author-visible identity whose uniqueness is part of a domain's public
+ * contract. The Frontend only carries the declaration; the owning Surface
+ * chooses the Type namespace and the Source closure enforces it generically.
+ */
+type AuthorSourceIdentity = {
+    readonly namespace: TypeRef;
+    readonly id: string;
+};
+type Awaitable<T> = T | Promise<T>;
+
+type MarkupReference = {
+    readonly kind: "reference";
+    readonly path: string;
+};
+type MarkupAttributeValue = string | MarkupReference;
+type StructuredText = {
+    readonly kind: "text";
+    readonly value: string;
+    readonly range: SourceRange;
+};
+type StructuredElement = {
+    readonly kind: "element";
+    readonly name: string;
+    readonly attributes: Readonly<Record<string, MarkupAttributeValue>>;
+    /** Exact ranges of literal/reference values in the opening tag. */
+    readonly attributeValueRanges?: Readonly<Record<string, SourceRange>>;
+    readonly children: readonly StructuredNode[];
+    readonly range: SourceRange;
+};
+type StructuredNode = StructuredText | StructuredElement;
+type SurfaceRecordDraft = {
+    readonly id: string;
+    readonly type: TypeRef;
+    readonly value: StoredValue;
+    readonly range: SourceRange;
+};
+/** Source-local diagnostics are removed before the component enters semantic elaboration. */
+type SurfaceComponentDraft = AuthorComponent & {
+    readonly range: SourceRange;
+};
+type SurfaceDecodeOutput = {
+    readonly records: readonly SurfaceRecordDraft[];
+    readonly components: readonly SurfaceComponentDraft[];
+    readonly fragments: readonly GraphFragment[];
+    /** Domain-owned public identities that must be unique in the Source closure. */
+    readonly identities?: readonly AuthorSourceIdentity[];
+    /**
+     * Public source bindings contributed by this Surface invocation. Omit to
+     * publish every generated binding; use an explicit list to keep plumbing
+     * addressable inside the source without exposing it from the source.
+     */
+    readonly exports?: readonly string[];
+};
+type StructuredSurfaceInput = {
+    readonly sourceName: string;
+    readonly element: StructuredElement;
+    /**
+     * Resolve an explicitly written author reference. Imported record values are
+     * available because their source has already been compiled and admitted.
+     * A component output has a ref and Type but no compile-time Record value.
+     */
+    readonly resolveReference: (path: string) => SurfaceResolvedReference | undefined;
+    readonly resolveAsset: (request: AuthorSourceAssetRequest) => Awaitable<ResolvedAuthorSourceAsset>;
+};
+type SurfaceResolvedReference = {
+    readonly path: string;
+    readonly ref: AuthorValueRef;
+    readonly type: TypeRef;
+    readonly record?: TypedRecord;
+};
+type StructuredSurfaceHandler = (input: StructuredSurfaceInput) => Awaitable<SurfaceDecodeOutput>;
+
+declare const decodeMediaImageSurface: StructuredSurfaceHandler;
+declare const decodeMediaAudioSurface: StructuredSurfaceHandler;
+declare const decodeMediaVideoSurface: StructuredSurfaceHandler;
+declare const decodeMediaFontSurface: StructuredSurfaceHandler;
+
+type TypeValidatorContext = {
+    readonly type: TypeRef;
+    readonly value: StoredValue;
+};
+
+declare const mediaComponent: {
+    validators: {
+        type: {
+            module: {
+                readonly name: "@hypit/media";
+                readonly version: "1";
+            };
+            name: string;
+        };
+        handler: ({ value }: TypeValidatorContext) => void;
+    }[];
+};
+
+type MediaRational = {
+    readonly numerator: number;
+    readonly denominator: number;
+};
+/** JSON-safe presentation timestamp: ticks * timeBase.numerator / timeBase.denominator. */
+type MediaTimestamp = {
+    readonly ticks: string;
+    readonly timeBase: MediaRational;
+};
+type MediaDisposition = {
+    readonly default: boolean;
+    readonly attachedPicture: boolean;
+};
+type MediaStreamBase = {
+    readonly index: number;
+    readonly codecType: string;
+    readonly codecName: string;
+    readonly disposition: MediaDisposition;
+    readonly timingStatus: "admissible" | "missing" | "non-monotonic" | "discontinuous";
+    readonly timeBase?: MediaRational;
+    readonly startPts?: MediaTimestamp;
+    readonly endPts?: MediaTimestamp;
+    readonly decodedUnitCount: number;
+};
+type MediaVideoStream = MediaStreamBase & {
+    readonly kind: "video";
+    readonly codecType: "video";
+    readonly role: "moving" | "attached-picture" | "still";
+    readonly width: number;
+    readonly height: number;
+    /** Coded-pixel width/height become display geometry only after this ratio and rotation are normalized. */
+    readonly sampleAspectRatio: MediaRational;
+    readonly rotationDegrees: 0 | 90 | 180 | 270;
+    readonly averageFrameRate?: MediaRational;
+    readonly nominalFrameRate?: MediaRational;
+};
+type MediaAudioStream = MediaStreamBase & {
+    readonly kind: "audio";
+    readonly codecType: "audio";
+    readonly sampleRate: number;
+    readonly channels: number;
+    readonly channelLayout?: string;
+    readonly decodedSampleFrames: number;
+};
+/** Subtitle, data, attachment and unknown streams remain visible instead of being discarded. */
+type MediaOtherStream = MediaStreamBase & {
+    readonly kind: "other";
+};
+type MediaStream = MediaVideoStream | MediaAudioStream | MediaOtherStream;
+/** Immutable observed facts about one exact media container. */
+type MediaInspection = {
+    readonly container: {
+        readonly formatNames: readonly string[];
+    };
+    readonly streams: readonly MediaStream[];
+};
+type MediaStreamSelection = {
+    readonly videoStreamIndex?: number;
+    readonly audioStreamIndex?: number;
+    readonly spanAuthority: "video" | "audio";
+    readonly policy: "primary-moving@1" | "default-audio@1" | "primary-moving-default-audio@1" | "explicit-streams@1";
+};
+type SynchronizedMedia = {
+    readonly timeline: {
+        readonly frameRate: MediaRational;
+        readonly frameCount: number;
+    };
+    readonly visual?: {
+        readonly artifact: BlobRef;
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly audio?: {
+        readonly artifact: BlobRef;
+    };
+};
+/** Silent, frame-exact visual output from a renderer such as HyperFrames. */
+type RenderedVisual = {
+    readonly frameRate: MediaRational;
+    readonly frameCount: number;
+    readonly canvas: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly artifact: BlobRef;
+};
+/** Exact 48 kHz stereo PCM result of one explicit timeline-audio plan. */
+type TimelineAudio = {
+    readonly artifact: BlobRef;
+    readonly sampleFrames: number;
+};
+/** Final mux result; visual rendering and program-audio preparation remain separate facts. */
+type MuxedMedia = {
+    readonly frameRate: MediaRational;
+    readonly frameCount: number;
+    readonly canvas: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly presentationSampleFrames: number;
+    readonly artifact: BlobRef;
+};
+
+declare function sealMediaInspection(value: MediaInspection): MediaInspection;
+declare function verifyMediaInspection(value: unknown): asserts value is MediaInspection;
+declare function sealMediaStreamSelection(value: MediaStreamSelection): MediaStreamSelection;
+declare function verifyMediaStreamSelection(value: unknown): asserts value is MediaStreamSelection;
+declare function sealSynchronizedMedia(value: SynchronizedMedia): SynchronizedMedia;
+/** Exact 48 kHz sample span implied by one normalized frame domain. */
+declare function synchronizedMediaSampleFrames(value: SynchronizedMedia): number;
+declare function verifySynchronizedMedia(value: unknown): asserts value is SynchronizedMedia;
+declare function sealRenderedVisual(value: RenderedVisual): RenderedVisual;
+declare function verifyRenderedVisual(value: unknown): asserts value is RenderedVisual;
+declare function sealTimelineAudio(value: TimelineAudio): TimelineAudio;
+declare function verifyTimelineAudio(value: unknown): asserts value is TimelineAudio;
+declare function sealMuxedMedia(value: MuxedMedia): MuxedMedia;
+declare function verifyMuxedMedia(value: unknown): asserts value is MuxedMedia;
+
+declare const mediaModuleRef: {
+    readonly name: "@hypit/media";
+    readonly version: "1";
+};
+declare const mediaTypes: {
+    frameRange: {
+        module: {
+            readonly name: "@hypit/media";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    inspection: {
+        module: {
+            readonly name: "@hypit/media";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    streamSelection: {
+        module: {
+            readonly name: "@hypit/media";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    synchronized: {
+        module: {
+            readonly name: "@hypit/media";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    renderedVisual: {
+        module: {
+            readonly name: "@hypit/media";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    timelineAudio: {
+        module: {
+            readonly name: "@hypit/media";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    muxed: {
+        module: {
+            readonly name: "@hypit/media";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    fontArtifact: {
+        module: {
+            readonly name: "@hypit/media";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    fontStack: {
+        module: {
+            readonly name: "@hypit/media";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    compositableSurface: {
+        module: {
+            readonly name: "@hypit/media";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    /** Declared by `@hypit/artifact`. A Type is identified by the Module that owns it, not the one that re-exports it. */
+    blobArtifact: {
+        module: {
+            readonly name: "@hypit/artifact";
+            readonly version: "1";
+        };
+        name: string;
+    };
+};
+declare const mediaMarkupSurfaces: readonly [{
+    readonly name: "image";
+    readonly tag: "Image";
+    readonly mode: "structured";
+    readonly outputs: readonly [{
+        module: {
+            readonly name: "@hypit/artifact";
+            readonly version: "1";
+        };
+        name: string;
+    }];
+    readonly vocabulary: {
+        readonly summary: "Requests one authored image file from the Host and publishes it as a byte Artifact.";
+        readonly attributes: readonly [{
+            readonly name: "id";
+            readonly kind: "identifier";
+            readonly required: true;
+            readonly summary: "Names the Artifact Record this element publishes.";
+        }, {
+            readonly name: "src";
+            readonly kind: "literal";
+            readonly required: true;
+            readonly summary: "Points at the image file, resolved by the Host against the source that declares it.";
+        }, {
+            readonly name: "media-type";
+            readonly kind: "literal";
+            readonly required: false;
+            readonly summary: "States the image media type when the src extension does not name one.";
+        }];
+        readonly example: "<media:Image id=\"presenter\" src=\"./assets/presenter.png\"/>";
+        readonly notes: readonly ["The element is empty; it accepts no children and no text.", "`.avif`, `.gif`, `.jpeg`, `.jpg`, `.png` and `.webp` name their own media type; any other file needs `media-type`.", "A written `media-type` must begin with `image/`, and the resolved bytes must arrive as an image Artifact.", "The Artifact is published under the bare `id`, and the consuming package decides what the image means."];
+    };
+}, {
+    readonly name: "audio";
+    readonly tag: "Audio";
+    readonly mode: "structured";
+    readonly outputs: readonly [{
+        module: {
+            readonly name: "@hypit/artifact";
+            readonly version: "1";
+        };
+        name: string;
+    }];
+    readonly vocabulary: {
+        readonly summary: "Requests one authored audio file from the Host and publishes it as a byte Artifact.";
+        readonly attributes: readonly [{
+            readonly name: "id";
+            readonly kind: "identifier";
+            readonly required: true;
+            readonly summary: "Names the Artifact Record this element publishes.";
+        }, {
+            readonly name: "src";
+            readonly kind: "literal";
+            readonly required: true;
+            readonly summary: "Points at the audio file, resolved by the Host against the source that declares it.";
+        }, {
+            readonly name: "media-type";
+            readonly kind: "literal";
+            readonly required: false;
+            readonly summary: "States the audio media type when the src extension does not name one.";
+        }];
+        readonly example: "<media:Audio id=\"music\" src=\"./assets/music.wav\"/>";
+        readonly notes: readonly ["The element is empty; it accepts no children and no text.", "`.aac`, `.flac`, `.m4a`, `.mp3`, `.oga`, `.ogg`, `.opus` and `.wav` name their own media type; any other file needs `media-type`.", "A written `media-type` must begin with `audio/`, and the resolved bytes must arrive as an audio Artifact.", "The Artifact is published under the bare `id`; declared audio is not promoted to speech here."];
+    };
+}, {
+    readonly name: "video";
+    readonly tag: "Video";
+    readonly mode: "structured";
+    readonly outputs: readonly [{
+        module: {
+            readonly name: "@hypit/artifact";
+            readonly version: "1";
+        };
+        name: string;
+    }];
+    readonly vocabulary: {
+        readonly summary: "Requests one authored video file from the Host and publishes it as a byte Artifact.";
+        readonly attributes: readonly [{
+            readonly name: "id";
+            readonly kind: "identifier";
+            readonly required: true;
+            readonly summary: "Names the Artifact Record this element publishes.";
+        }, {
+            readonly name: "src";
+            readonly kind: "literal";
+            readonly required: true;
+            readonly summary: "Points at the video file, resolved by the Host against the source that declares it.";
+        }, {
+            readonly name: "media-type";
+            readonly kind: "literal";
+            readonly required: false;
+            readonly summary: "States the video media type when the src extension does not name one.";
+        }];
+        readonly example: "<media:Video id=\"reference\" src=\"./assets/reference.mp4\"/>";
+        readonly notes: readonly ["The element is empty; it accepts no children and no text.", "`.m4v`, `.mov`, `.mp4` and `.webm` name their own media type; any other file needs `media-type`.", "A written `media-type` must begin with `video/`, and the resolved bytes must arrive as a video Artifact.", "The Artifact is published under the bare `id`, and the consuming package decides what the video means."];
+    };
+}, {
+    readonly name: "font";
+    readonly tag: "Font";
+    readonly mode: "structured";
+    readonly outputs: readonly [{
+        module: {
+            readonly name: "@hypit/media";
+            readonly version: "1";
+        };
+        name: string;
+    }];
+    readonly vocabulary: {
+        readonly summary: "Requests one authored font file from the Host and publishes it with its exact weight and style as a one-source FontArtifact.";
+        readonly attributes: readonly [{
+            readonly name: "id";
+            readonly kind: "identifier";
+            readonly required: true;
+            readonly summary: "Names the FontArtifact Record this element publishes.";
+        }, {
+            readonly name: "src";
+            readonly kind: "literal";
+            readonly required: true;
+            readonly summary: "Points at the font file, resolved by the Host against the source that declares it.";
+        }, {
+            readonly name: "weight";
+            readonly kind: "literal";
+            readonly required: true;
+            readonly summary: "States the exact weight the bytes carry, as a whole number from 1 to 1000.";
+        }, {
+            readonly name: "style";
+            readonly kind: "literal";
+            readonly required: true;
+            readonly values: readonly ["normal", "italic", "oblique"];
+            readonly summary: "States the exact style the bytes carry.";
+        }, {
+            readonly name: "media-type";
+            readonly kind: "literal";
+            readonly required: false;
+            readonly summary: "States the font media type when the src extension does not name one.";
+        }];
+        readonly example: "<media:Font id=\"brand\" src=\"./assets/Brand-Semibold.woff2\" weight=\"600\" style=\"normal\"/>";
+        readonly notes: readonly ["The element is empty; it accepts no children and no text.", "`.otf`, `.ttf`, `.woff` and `.woff2` name their own media type; any other file needs `media-type`.", "One element declares one face, so `weight` and `style` describe these bytes rather than a family.", "The FontArtifact is published under the bare `id`, and an invalid weight or style fails before any bytes are read."];
+    };
+}];
+declare const mediaManifest: ModuleManifest;
+declare const mediaDependency: {
+    readonly module: {
+        readonly name: "@hypit/media";
+        readonly version: "1";
+    };
+};
+
+declare const mediaInspectionSchema: ValueSchema;
+declare const mediaStreamSelectionSchema: ValueSchema;
+declare const synchronizedMediaSchema: ValueSchema;
+declare const renderedVisualSchema: ValueSchema;
+declare const timelineAudioSchema: ValueSchema;
+declare const muxedMediaSchema: ValueSchema;
+declare const fontArtifactSchema: ValueSchema;
+declare const fontStackSchema: ValueSchema;
+declare const compositableSurfaceSchema: ValueSchema;
+
+type FontArtifactRef = {
+    /** One logical face may be split into independently addressed Unicode-range sources. */
+    readonly sources: readonly {
+        readonly artifact: BlobRef;
+        readonly unicodeRange?: string;
+    }[];
+    readonly weight: number;
+    readonly style: "normal" | "italic" | "oblique";
+};
+/** Ordered exact font faces. The first face is primary; the remainder are glyph fallbacks. */
+type FontStackRef = {
+    readonly faces: readonly FontArtifactRef[];
+};
+type CompositableSurfaceRef = {
+    readonly artifact: BlobRef;
+    readonly width: number;
+    readonly height: number;
+    readonly colorSpace: "srgb";
+    readonly alphaMode: "opaque" | "straight";
+    readonly timing: {
+        readonly kind: "still";
+    } | {
+        readonly kind: "frames";
+        readonly frameRate: {
+            readonly numerator: number;
+            readonly denominator: number;
+        };
+        readonly frameCount: number;
+    };
+};
+declare function assertFontArtifactRef(value: FontArtifactRef, label?: string): void;
+declare function assertFontStackRef(value: FontStackRef, label?: string): void;
+declare function assertCompositableSurfaceRef(value: CompositableSurfaceRef, label?: string): void;
+
+/** A half-open selection on the original programme frame clock. */
+type MediaFrameRange = {
+    readonly startFrame: number;
+    readonly endFrameExclusive: number;
+};
+declare function verifyMediaFrameRange(value: unknown, frameCount?: number): asserts value is MediaFrameRange;
+/**
+ * Start on the original clock; duration belongs to the new zero-based frame clock.
+ * At rational rates, rounding the two clocks can differ by one PCM sample.
+ */
+declare function mediaFrameRangeSamples(range: MediaFrameRange, frameRate: MediaRational): {
+    startSample: number;
+    endSampleExclusive: number;
+    sampleFrames: number;
+};
+
+export { assertCompositableSurfaceRef, assertFontArtifactRef, assertFontStackRef, compositableSurfaceSchema, decodeMediaAudioSurface, decodeMediaFontSurface, decodeMediaImageSurface, decodeMediaVideoSurface, fontArtifactSchema, fontStackSchema, mediaComponent, mediaDependency, mediaFrameRangeSamples, mediaInspectionSchema, mediaManifest, mediaMarkupSurfaces, mediaModuleRef, mediaStreamSelectionSchema, mediaTypes, muxedMediaSchema, renderedVisualSchema, sealMediaInspection, sealMediaStreamSelection, sealMuxedMedia, sealRenderedVisual, sealSynchronizedMedia, sealTimelineAudio, synchronizedMediaSampleFrames, synchronizedMediaSchema, timelineAudioSchema, verifyMediaFrameRange, verifyMediaInspection, verifyMediaStreamSelection, verifyMuxedMedia, verifyRenderedVisual, verifySynchronizedMedia, verifyTimelineAudio };
+export type { CompositableSurfaceRef, FontArtifactRef, FontStackRef, MediaAudioStream, MediaDisposition, MediaFrameRange, MediaInspection, MediaOtherStream, MediaRational, MediaStream, MediaStreamSelection, MediaTimestamp, MediaVideoStream, MuxedMedia, RenderedVisual, SynchronizedMedia, TimelineAudio };