declare module "windows.ui.composition" {
  export class Color {
    constructor();
  }

  export class Matrix3x2 {
    m11: Number;
    m12: Number;
    m21: Number;
    m22: Number;
    m31: Number;
    m32: Number;
    constructor();
  }

  export class Matrix4x4 {
    m11: Number;
    m12: Number;
    m13: Number;
    m14: Number;
    m21: Number;
    m22: Number;
    m23: Number;
    m24: Number;
    m31: Number;
    m32: Number;
    m33: Number;
    m34: Number;
    m41: Number;
    m42: Number;
    m43: Number;
    m44: Number;
    constructor();
  }

  export class Quaternion {
    x: Number;
    y: Number;
    z: Number;
    w: Number;
    constructor();
  }

  export class Vector2 {
    x: Number;
    y: Number;
    constructor();
  }

  export class Vector3 {
    x: Number;
    y: Number;
    z: Number;
    constructor();
  }

  export class Vector4 {
    x: Number;
    y: Number;
    z: Number;
    w: Number;
    constructor();
  }

  export class Size {
    constructor();
  }

  export enum AnimationDirection {
    normal,
    reverse,
    alternate,
    alternateReverse,
  }

  export enum AnimationIterationBehavior {
    count,
    forever,
  }

  export enum AnimationStopBehavior {
    leaveCurrentValue,
    setToInitialValue,
    setToFinalValue,
  }

  export enum CompositionBatchTypes {
    none,
    animation,
    effect,
  }

  export enum CompositionBackfaceVisibility {
    inherit,
    visible,
    hidden,
  }

  export enum CompositionBitmapInterpolationMode {
    nearestNeighbor,
    linear,
  }

  export enum CompositionBorderMode {
    inherit,
    soft,
    hard,
  }

  export enum CompositionColorSpace {
    auto,
    hsl,
    rgb,
  }

  export enum CompositionCompositeMode {
    inherit,
    sourceOver,
    destinationInvert,
    minBlend,
  }

  export enum CompositionEffectFactoryLoadStatus {
    success,
    effectTooComplex,
    pending,
    other,
  }

  export enum CompositionGetValueStatus {
    succeeded,
    typeMismatch,
    notFound,
  }

  export enum CompositionStretch {
    none,
    fill,
    uniform,
    uniformToFill,
  }

  export class CompositionObject {
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    startAnimation(propertyName: String, animation: CompositionAnimation): void;

    stopAnimation(propertyName: String): void;

    close(): void;
    startAnimationGroup(value: ICompositionAnimationBase): void;

    stopAnimationGroup(value: ICompositionAnimationBase): void;

  }

  export class ICompositionAnimationBase {
    constructor();

  }

  export class CompositionAnimation {
    target: String;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    clearAllParameters(): void;

    clearParameter(key: String): void;

    setColorParameter(key: String, value: Object): void;

    setMatrix3x2Parameter(key: String, value: Matrix3x2): void;

    setMatrix4x4Parameter(key: String, value: Matrix4x4): void;

    setQuaternionParameter(key: String, value: Quaternion): void;

    setReferenceParameter(key: String, compositionObject: CompositionObject): void;

    setScalarParameter(key: String, value: Number): void;

    setVector2Parameter(key: String, value: Vector2): void;

    setVector3Parameter(key: String, value: Vector3): void;

    setVector4Parameter(key: String, value: Vector4): void;

    setBooleanParameter(key: String, value: Boolean): void;

  }

  export class CompositionBatchCompletedEventArgs {
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class CompositionEasingFunction {
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class CompositionBrush {
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class CompositionEffectBrush {
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    getSourceParameter(name: String): CompositionBrush;

    setSourceParameter(name: String, source: CompositionBrush): void;

  }

  export class CompositionEffectSourceParameter {
    name: String;
    constructor();
    constructor(name: String);

  }

  export class CompositionGraphicsDevice {
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    createDrawingSurface(sizePixels: Object, pixelFormat: Number, alphaMode: Number): CompositionDrawingSurface;

    addListener(type: "RenderingDeviceReplaced", listener: (ev: Event) => void): void ;
    removeListener(type: "RenderingDeviceReplaced", listener: (ev: Event) => void): void ;
    on(type: "RenderingDeviceReplaced", listener: (ev: Event) => void): void ;
    off(type: "RenderingDeviceReplaced", listener: (ev: Event) => void): void ;
    
    addListener(type: string, listener: (ev: Event) => void): void ;
    removeListener(type: string, listener: (ev: Event) => void): void ;
    on(type: string, listener: (ev: Event) => void): void ;
    off(type: string, listener: (ev: Event) => void): void ;
    

  }

  export class Compositor {
    constructor();

    createColorKeyFrameAnimation(): ColorKeyFrameAnimation;

    createColorBrush(): CompositionColorBrush;
    createColorBrush(color: Object): CompositionColorBrush;

    createContainerVisual(): ContainerVisual;

    createCubicBezierEasingFunction(controlPoint1: Vector2, controlPoint2: Vector2): CubicBezierEasingFunction;

    createEffectFactory(graphicsEffect: Object): CompositionEffectFactory;
    createEffectFactory(graphicsEffect: Object, animatableProperties: Object): CompositionEffectFactory;

    createExpressionAnimation(): ExpressionAnimation;
    createExpressionAnimation(expression: String): ExpressionAnimation;

    createInsetClip(): InsetClip;
    createInsetClip(leftInset: Number, topInset: Number, rightInset: Number, bottomInset: Number): InsetClip;

    createLinearEasingFunction(): LinearEasingFunction;

    createPropertySet(): CompositionPropertySet;

    createQuaternionKeyFrameAnimation(): QuaternionKeyFrameAnimation;

    createScalarKeyFrameAnimation(): ScalarKeyFrameAnimation;

    createScopedBatch(batchType: CompositionBatchTypes): CompositionScopedBatch;

    createSpriteVisual(): SpriteVisual;

    createSurfaceBrush(): CompositionSurfaceBrush;
    createSurfaceBrush(surface: ICompositionSurface): CompositionSurfaceBrush;

    createTargetForCurrentView(): CompositionTarget;

    createVector2KeyFrameAnimation(): Vector2KeyFrameAnimation;

    createVector3KeyFrameAnimation(): Vector3KeyFrameAnimation;

    createVector4KeyFrameAnimation(): Vector4KeyFrameAnimation;

    getCommitBatch(batchType: CompositionBatchTypes): CompositionCommitBatch;

    close(): void;
    createAmbientLight(): AmbientLight;

    createAnimationGroup(): CompositionAnimationGroup;

    createBackdropBrush(): CompositionBackdropBrush;

    createDistantLight(): DistantLight;

    createDropShadow(): DropShadow;

    createImplicitAnimationCollection(): ImplicitAnimationCollection;

    createLayerVisual(): LayerVisual;

    createMaskBrush(): CompositionMaskBrush;

    createNineGridBrush(): CompositionNineGridBrush;

    createPointLight(): PointLight;

    createSpotLight(): SpotLight;

    createStepEasingFunction(): StepEasingFunction;
    createStepEasingFunction(stepCount: Number): StepEasingFunction;

  }

  export class CompositionPropertySet {
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    insertColor(propertyName: String, value: Object): void;

    insertMatrix3x2(propertyName: String, value: Matrix3x2): void;

    insertMatrix4x4(propertyName: String, value: Matrix4x4): void;

    insertQuaternion(propertyName: String, value: Quaternion): void;

    insertScalar(propertyName: String, value: Number): void;

    insertVector2(propertyName: String, value: Vector2): void;

    insertVector3(propertyName: String, value: Vector3): void;

    insertVector4(propertyName: String, value: Vector4): void;

    tryGetColor(propertyName: String, value: Object): CompositionGetValueStatus;

    tryGetMatrix3x2(propertyName: String, value: Matrix3x2): CompositionGetValueStatus;

    tryGetMatrix4x4(propertyName: String, value: Matrix4x4): CompositionGetValueStatus;

    tryGetQuaternion(propertyName: String, value: Quaternion): CompositionGetValueStatus;

    tryGetScalar(propertyName: String, value: Number): CompositionGetValueStatus;

    tryGetVector2(propertyName: String, value: Vector2): CompositionGetValueStatus;

    tryGetVector3(propertyName: String, value: Vector3): CompositionGetValueStatus;

    tryGetVector4(propertyName: String, value: Vector4): CompositionGetValueStatus;

    insertBoolean(propertyName: String, value: Boolean): void;

    tryGetBoolean(propertyName: String, value: Boolean): CompositionGetValueStatus;

  }

  export class ICompositionSurface {
    constructor();

  }

  export class CompositionDrawingSurface {
    alphaMode: Number;
    pixelFormat: Number;
    size: Object;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class CompositionColorBrush {
    color: Object;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class CompositionEffectFactory {
    extendedError: Number;
    loadStatus: CompositionEffectFactoryLoadStatus;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    createBrush(): CompositionEffectBrush;

  }

  export class CompositionScopedBatch {
    isActive: Boolean;
    isEnded: Boolean;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    end(): void;

    resume(): void;

    suspend(): void;

    addListener(type: "Completed", listener: (ev: Event) => void): void ;
    removeListener(type: "Completed", listener: (ev: Event) => void): void ;
    on(type: "Completed", listener: (ev: Event) => void): void ;
    off(type: "Completed", listener: (ev: Event) => void): void ;
    
    addListener(type: string, listener: (ev: Event) => void): void ;
    removeListener(type: string, listener: (ev: Event) => void): void ;
    on(type: string, listener: (ev: Event) => void): void ;
    off(type: string, listener: (ev: Event) => void): void ;
    

  }

  export class CompositionSurfaceBrush {
    verticalAlignmentRatio: Number;
    surface: ICompositionSurface;
    stretch: CompositionStretch;
    horizontalAlignmentRatio: Number;
    bitmapInterpolationMode: CompositionBitmapInterpolationMode;
    anchorPoint: Vector2;
    transformMatrix: Matrix3x2;
    scale: Vector2;
    rotationAngleInDegrees: Number;
    rotationAngle: Number;
    offset: Vector2;
    centerPoint: Vector2;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class CompositionTarget {
    root: Visual;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class CompositionCommitBatch {
    isActive: Boolean;
    isEnded: Boolean;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    addListener(type: "Completed", listener: (ev: Event) => void): void ;
    removeListener(type: "Completed", listener: (ev: Event) => void): void ;
    on(type: "Completed", listener: (ev: Event) => void): void ;
    off(type: "Completed", listener: (ev: Event) => void): void ;
    
    addListener(type: string, listener: (ev: Event) => void): void ;
    removeListener(type: string, listener: (ev: Event) => void): void ;
    on(type: string, listener: (ev: Event) => void): void ;
    off(type: string, listener: (ev: Event) => void): void ;
    

  }

  export class CompositionAnimationGroup {
    count: Number;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    add(value: CompositionAnimation): void;

    remove(value: CompositionAnimation): void;

    removeAll(): void;

    first(): Object;

  }

  export class CompositionBackdropBrush {
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class CompositionMaskBrush {
    source: CompositionBrush;
    mask: CompositionBrush;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class CompositionNineGridBrush {
    topInsetScale: Number;
    topInset: Number;
    source: CompositionBrush;
    rightInsetScale: Number;
    rightInset: Number;
    leftInsetScale: Number;
    leftInset: Number;
    isCenterHollow: Boolean;
    bottomInsetScale: Number;
    bottomInset: Number;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    setInsets(inset: Number): void;
    setInsets(left: Number, top: Number, right: Number, bottom: Number): void;

    setInsetScales(scale: Number): void;
    setInsetScales(left: Number, top: Number, right: Number, bottom: Number): void;

  }

  export class CubicBezierEasingFunction {
    controlPoint1: Vector2;
    controlPoint2: Vector2;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class ExpressionAnimation {
    expression: String;
    target: String;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class ImplicitAnimationCollection {
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    lookup(key: String): ICompositionAnimationBase;

    hasKey(key: String): Boolean;

    getView(): Object;

    insert(key: String, value: ICompositionAnimationBase): Boolean;

    remove(key: String): void;

    clear(): void;

    first(): Object;

  }

  export class LinearEasingFunction {
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class RenderingDeviceReplacedEventArgs {
    graphicsDevice: CompositionGraphicsDevice;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class CompositionShadow {
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class DropShadow {
    opacity: Number;
    offset: Vector3;
    mask: CompositionBrush;
    color: Object;
    blurRadius: Number;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class StepEasingFunction {
    stepCount: Number;
    isInitialStepSingleFrame: Boolean;
    isFinalStepSingleFrame: Boolean;
    initialStep: Number;
    finalStep: Number;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class Visual {
    offset: Vector3;
    isVisible: Boolean;
    compositeMode: CompositionCompositeMode;
    clip: CompositionClip;
    centerPoint: Vector3;
    borderMode: CompositionBorderMode;
    scale: Vector3;
    backfaceVisibility: CompositionBackfaceVisibility;
    anchorPoint: Vector2;
    rotationAngleInDegrees: Number;
    size: Vector2;
    rotationAxis: Vector3;
    transformMatrix: Matrix4x4;
    rotationAngle: Number;
    orientation: Quaternion;
    opacity: Number;
    parent: ContainerVisual;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class ContainerVisual {
    children: VisualCollection;
    offset: Vector3;
    isVisible: Boolean;
    compositeMode: CompositionCompositeMode;
    clip: CompositionClip;
    centerPoint: Vector3;
    borderMode: CompositionBorderMode;
    scale: Vector3;
    backfaceVisibility: CompositionBackfaceVisibility;
    anchorPoint: Vector2;
    rotationAngleInDegrees: Number;
    size: Vector2;
    rotationAxis: Vector3;
    transformMatrix: Matrix4x4;
    rotationAngle: Number;
    orientation: Quaternion;
    opacity: Number;
    parent: ContainerVisual;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class SpriteVisual {
    brush: CompositionBrush;
    shadow: CompositionShadow;
    children: VisualCollection;
    offset: Vector3;
    isVisible: Boolean;
    compositeMode: CompositionCompositeMode;
    clip: CompositionClip;
    centerPoint: Vector3;
    borderMode: CompositionBorderMode;
    scale: Vector3;
    backfaceVisibility: CompositionBackfaceVisibility;
    anchorPoint: Vector2;
    rotationAngleInDegrees: Number;
    size: Vector2;
    rotationAxis: Vector3;
    transformMatrix: Matrix4x4;
    rotationAngle: Number;
    orientation: Quaternion;
    opacity: Number;
    parent: ContainerVisual;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class LayerVisual {
    effect: CompositionEffectBrush;
    children: VisualCollection;
    offset: Vector3;
    isVisible: Boolean;
    compositeMode: CompositionCompositeMode;
    clip: CompositionClip;
    centerPoint: Vector3;
    borderMode: CompositionBorderMode;
    scale: Vector3;
    backfaceVisibility: CompositionBackfaceVisibility;
    anchorPoint: Vector2;
    rotationAngleInDegrees: Number;
    size: Vector2;
    rotationAxis: Vector3;
    transformMatrix: Matrix4x4;
    rotationAngle: Number;
    orientation: Quaternion;
    opacity: Number;
    parent: ContainerVisual;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class CompositionClip {
    transformMatrix: Matrix3x2;
    scale: Vector2;
    rotationAngleInDegrees: Number;
    rotationAngle: Number;
    offset: Vector2;
    centerPoint: Vector2;
    anchorPoint: Vector2;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class InsetClip {
    topInset: Number;
    rightInset: Number;
    leftInset: Number;
    bottomInset: Number;
    transformMatrix: Matrix3x2;
    scale: Vector2;
    rotationAngleInDegrees: Number;
    rotationAngle: Number;
    offset: Vector2;
    centerPoint: Vector2;
    anchorPoint: Vector2;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class VisualCollection {
    count: Number;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    insertAbove(newChild: Visual, sibling: Visual): void;

    insertAtBottom(newChild: Visual): void;

    insertAtTop(newChild: Visual): void;

    insertBelow(newChild: Visual, sibling: Visual): void;

    remove(child: Visual): void;

    removeAll(): void;

    first(): Object;

  }

  export class VisualUnorderedCollection {
    count: Number;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    add(newVisual: Visual): void;

    remove(visual: Visual): void;

    removeAll(): void;

    first(): Object;

  }

  export class CompositionLight {
    targets: VisualUnorderedCollection;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class AmbientLight {
    color: Object;
    targets: VisualUnorderedCollection;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class DistantLight {
    direction: Vector3;
    coordinateSpace: Visual;
    color: Object;
    targets: VisualUnorderedCollection;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class PointLight {
    quadraticAttenuation: Number;
    offset: Vector3;
    linearAttenuation: Number;
    coordinateSpace: Visual;
    constantAttenuation: Number;
    color: Object;
    targets: VisualUnorderedCollection;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class SpotLight {
    innerConeColor: Object;
    innerConeAngleInDegrees: Number;
    innerConeAngle: Number;
    direction: Vector3;
    coordinateSpace: Visual;
    constantAttenuation: Number;
    quadraticAttenuation: Number;
    outerConeColor: Object;
    outerConeAngleInDegrees: Number;
    outerConeAngle: Number;
    offset: Vector3;
    linearAttenuation: Number;
    targets: VisualUnorderedCollection;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

  }

  export class KeyFrameAnimation {
    stopBehavior: AnimationStopBehavior;
    iterationCount: Number;
    iterationBehavior: AnimationIterationBehavior;
    duration: Number;
    delayTime: Number;
    keyFrameCount: Number;
    direction: AnimationDirection;
    target: String;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    insertExpressionKeyFrame(normalizedProgressKey: Number, value: String): void;
    insertExpressionKeyFrame(normalizedProgressKey: Number, value: String, easingFunction: CompositionEasingFunction): void;

  }

  export class ColorKeyFrameAnimation {
    interpolationColorSpace: CompositionColorSpace;
    stopBehavior: AnimationStopBehavior;
    iterationCount: Number;
    iterationBehavior: AnimationIterationBehavior;
    duration: Number;
    delayTime: Number;
    keyFrameCount: Number;
    direction: AnimationDirection;
    target: String;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    insertKeyFrame(normalizedProgressKey: Number, value: Object): void;
    insertKeyFrame(normalizedProgressKey: Number, value: Object, easingFunction: CompositionEasingFunction): void;

  }

  export class QuaternionKeyFrameAnimation {
    stopBehavior: AnimationStopBehavior;
    iterationCount: Number;
    iterationBehavior: AnimationIterationBehavior;
    duration: Number;
    delayTime: Number;
    keyFrameCount: Number;
    direction: AnimationDirection;
    target: String;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    insertKeyFrame(normalizedProgressKey: Number, value: Quaternion): void;
    insertKeyFrame(normalizedProgressKey: Number, value: Quaternion, easingFunction: CompositionEasingFunction): void;

  }

  export class ScalarKeyFrameAnimation {
    stopBehavior: AnimationStopBehavior;
    iterationCount: Number;
    iterationBehavior: AnimationIterationBehavior;
    duration: Number;
    delayTime: Number;
    keyFrameCount: Number;
    direction: AnimationDirection;
    target: String;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    insertKeyFrame(normalizedProgressKey: Number, value: Number): void;
    insertKeyFrame(normalizedProgressKey: Number, value: Number, easingFunction: CompositionEasingFunction): void;

  }

  export class Vector2KeyFrameAnimation {
    stopBehavior: AnimationStopBehavior;
    iterationCount: Number;
    iterationBehavior: AnimationIterationBehavior;
    duration: Number;
    delayTime: Number;
    keyFrameCount: Number;
    direction: AnimationDirection;
    target: String;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    insertKeyFrame(normalizedProgressKey: Number, value: Vector2): void;
    insertKeyFrame(normalizedProgressKey: Number, value: Vector2, easingFunction: CompositionEasingFunction): void;

  }

  export class Vector3KeyFrameAnimation {
    stopBehavior: AnimationStopBehavior;
    iterationCount: Number;
    iterationBehavior: AnimationIterationBehavior;
    duration: Number;
    delayTime: Number;
    keyFrameCount: Number;
    direction: AnimationDirection;
    target: String;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    insertKeyFrame(normalizedProgressKey: Number, value: Vector3): void;
    insertKeyFrame(normalizedProgressKey: Number, value: Vector3, easingFunction: CompositionEasingFunction): void;

  }

  export class Vector4KeyFrameAnimation {
    stopBehavior: AnimationStopBehavior;
    iterationCount: Number;
    iterationBehavior: AnimationIterationBehavior;
    duration: Number;
    delayTime: Number;
    keyFrameCount: Number;
    direction: AnimationDirection;
    target: String;
    compositor: Compositor;
    dispatcher: Object;
    properties: CompositionPropertySet;
    implicitAnimations: ImplicitAnimationCollection;
    comment: String;
    constructor();

    insertKeyFrame(normalizedProgressKey: Number, value: Vector4): void;
    insertKeyFrame(normalizedProgressKey: Number, value: Vector4, easingFunction: CompositionEasingFunction): void;

  }

}